@tscircuit/cli 0.1.1209 → 0.1.1210

package/dist/cli/main.js

@@ -37959,7 +37959,7 @@ var init_chunk_SK323GHE = __esm(() => {
           debug2.namespace = namespace;
           debug2.useColors = createDebug.useColors();
           debug2.color = createDebug.selectColor(namespace);
-          debug2.extend = extend;
+          debug2.extend = extend2;
           debug2.destroy = createDebug.destroy;
           Object.defineProperty(debug2, "enabled", {
             enumerable: true,
@@ -37983,7 +37983,7 @@ var init_chunk_SK323GHE = __esm(() => {
           }
           return debug2;
         }
-        function extend(namespace, delimiter) {
+        function extend2(namespace, delimiter) {
           const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
           newDebug.log = this.log;
           return newDebug;
@@ -39002,7 +39002,7 @@ var init_chunk_SK323GHE = __esm(() => {
         element: "element",
         text: "text"
       };
-      var createNode = function createNode2(params2) {
+      var createNode2 = function createNode22(params2) {
         return Object.assign({
           name: "",
           type: NodeType.element,
@@ -39030,7 +39030,7 @@ var init_chunk_SK323GHE = __esm(() => {
                 current2 = rootNode;
                 current2.name = data.value;
               } else {
-                var node = createNode({
+                var node = createNode2({
                   name: data.value,
                   parent: current2
                 });
@@ -39063,7 +39063,7 @@ var init_chunk_SK323GHE = __esm(() => {
               break;
             case Type.text:
               if (current2) {
-                current2.children.push(createNode({
+                current2.children.push(createNode2({
                   type: NodeType.text,
                   value: data.value,
                   parent: options.parentNodes ? current2 : null
@@ -39082,7 +39082,7 @@ var init_chunk_SK323GHE = __esm(() => {
         reader.reset = function() {
           lexer = Lexer.create({ debug: options.debug });
           lexer.on("data", handleLexerData);
-          rootNode = createNode();
+          rootNode = createNode2();
           current2 = null;
           attrName = "";
           reader.parse = lexer.write;
@@ -95866,7 +95866,7 @@ See: https://github.com/isaacs/node-glob/issues/167`);
       glob2.sync = globSync;
       var GlobSync = glob2.GlobSync = globSync.GlobSync;
       glob2.glob = glob2;
-      function extend(origin, add) {
+      function extend2(origin, add) {
         if (add === null || typeof add !== "object") {
           return origin;
         }
@@ -95878,7 +95878,7 @@ See: https://github.com/isaacs/node-glob/issues/167`);
         return origin;
       }
       glob2.hasMagic = function(pattern, options_) {
-        var options = extend({}, options_);
+        var options = extend2({}, options_);
         options.noprocess = true;
         var g6 = new Glob(pattern, options);
         var set = g6.minimatch.set;
@@ -99964,7 +99964,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.1208";
+var version = "0.1.1209";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -99976,7 +99976,7 @@ var package_default = {
   devDependencies: {
     "@babel/standalone": "^7.26.9",
     "@biomejs/biome": "^1.9.4",
-    "@tscircuit/circuit-json-placement-analysis": "^0.0.5",
+    "@tscircuit/circuit-json-placement-analysis": "^0.0.6",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.1",
     "@tscircuit/fake-snippets": "^0.0.182",
     "@tscircuit/file-server": "^0.0.32",
@@ -99996,13 +99996,15 @@ var package_default = {
     "bun-match-svg": "^0.0.12",
     chokidar: "4.0.1",
     "circuit-json": "^0.0.403",
-    "circuit-json-to-gerber": "^0.0.48",
     "circuit-json-to-bom-csv": "^0.0.7",
-    "circuit-json-to-pnp-csv": "^0.0.7",
+    "circuit-json-to-gerber": "^0.0.48",
     "circuit-json-to-kicad": "^0.0.96",
+    "circuit-json-to-pnp-csv": "^0.0.7",
     "circuit-json-to-readable-netlist": "^0.0.15",
     "circuit-json-to-spice": "^0.0.10",
+    "circuit-json-to-step": "^0.0.20",
     "circuit-json-to-tscircuit": "^0.0.9",
+    "circuit-json-trace-length-analysis": "github:tscircuit/circuit-json-trace-length-analysis#2b44792a40df0ca83b6bfb6ac95ed5e35e7168b8",
     commander: "^14.0.0",
     conf: "^13.1.0",
     configstore: "^7.0.0",
@@ -100030,13 +100032,12 @@ var package_default = {
     prompts: "^2.4.2",
     redaxios: "^0.5.1",
     semver: "^7.6.3",
+    stepts: "^0.0.3",
     tempy: "^3.1.0",
     tscircuit: "0.0.1590-libonly",
     tsx: "^4.7.1",
     "typed-ky": "^0.0.4",
-    zod: "^3.23.8",
-    "circuit-json-to-step": "^0.0.20",
-    stepts: "^0.0.3"
+    zod: "^3.23.8"
   },
   peerDependencies: {
     tscircuit: "*"
@@ -111779,7 +111780,12 @@ var convertCircuitJsonToReadableNetlist = (circuitJson) => {
 };
 
 // cli/check/netlist/register.ts
+import {
+  categorizeErrorOrWarning as categorizeErrorOrWarning2
+} from "@tscircuit/circuit-json-util";
 import path40 from "node:path";
+var normalizeCategory2 = (category) => category === "netlist" || category === "pin_specification" || category === "placement" || category === "routing" ? category : "unknown";
+var isNetlistDiagnostic = (issue) => normalizeCategory2(categorizeErrorOrWarning2(issue)) === "netlist";
 var resolveInputFilePath = async (file) => {
   if (file) {
     return path40.isAbsolute(file) ? file : path40.resolve(process.cwd(), file);
@@ -111805,13 +111811,21 @@ var checkNetlist = async (file) => {
   });
   const typedCircuitJson = circuitJson;
   const diagnostics = analyzeCircuitJson(typedCircuitJson);
+  const netlistErrors = diagnostics.errors.filter(isNetlistDiagnostic);
+  const netlistWarnings = diagnostics.warnings.filter(isNetlistDiagnostic);
   const readableNetlist = convertCircuitJsonToReadableNetlist(typedCircuitJson);
   const diagnosticsLines = [
-    `Errors: ${diagnostics.errors.length}`,
-    `Warnings: ${diagnostics.warnings.length}`
+    `Errors: ${netlistErrors.length}`,
+    `Warnings: ${netlistWarnings.length}`
   ];
-  if (diagnostics.errors.length > 0) {
-    diagnosticsLines.push(...diagnostics.errors.map((err) => `- ${err.type}: ${err.message ?? ""}`));
+  if (netlistErrors.length > 0) {
+    diagnosticsLines.push(...netlistErrors.map((err) => `- ${err.type}: ${err.message ?? ""}`));
+  }
+  if (netlistWarnings.length > 0) {
+    diagnosticsLines.push(...netlistWarnings.map((warning) => {
+      const issueType = warning.warning_type ?? warning.error_type ?? warning.type;
+      return `- ${issueType}: ${warning.message ?? ""}`;
+    }));
   }
   return `${diagnosticsLines.join(`
 `)}
@@ -111914,6 +111928,454 @@ var registerCheckPinSpecification = (program2) => {
   });
 };
 
+// node_modules/@tscircuit/circuit-json-placement-analysis/dist/index.js
+import Flatbush from "flatbush";
+
+// node_modules/quickselect/index.js
+function quickselect(arr, k, left = 0, right = arr.length - 1, compare = defaultCompare) {
+  while (right > left) {
+    if (right - left > 600) {
+      const n = right - left + 1;
+      const m = k - left + 1;
+      const z2 = Math.log(n);
+      const s = 0.5 * Math.exp(2 * z2 / 3);
+      const sd = 0.5 * Math.sqrt(z2 * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
+      const newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
+      const newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
+      quickselect(arr, k, newLeft, newRight, compare);
+    }
+    const t = arr[k];
+    let i = left;
+    let j = right;
+    swap(arr, left, k);
+    if (compare(arr[right], t) > 0)
+      swap(arr, left, right);
+    while (i < j) {
+      swap(arr, i, j);
+      i++;
+      j--;
+      while (compare(arr[i], t) < 0)
+        i++;
+      while (compare(arr[j], t) > 0)
+        j--;
+    }
+    if (compare(arr[left], t) === 0)
+      swap(arr, left, j);
+    else {
+      j++;
+      swap(arr, j, right);
+    }
+    if (j <= k)
+      left = j + 1;
+    if (k <= j)
+      right = j - 1;
+  }
+}
+function swap(arr, i, j) {
+  const tmp = arr[i];
+  arr[i] = arr[j];
+  arr[j] = tmp;
+}
+function defaultCompare(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+// node_modules/rbush/index.js
+class RBush {
+  constructor(maxEntries = 9) {
+    this._maxEntries = Math.max(4, maxEntries);
+    this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));
+    this.clear();
+  }
+  all() {
+    return this._all(this.data, []);
+  }
+  search(bbox) {
+    let node = this.data;
+    const result = [];
+    if (!intersects(bbox, node))
+      return result;
+    const toBBox = this.toBBox;
+    const nodesToSearch = [];
+    while (node) {
+      for (let i = 0;i < node.children.length; i++) {
+        const child = node.children[i];
+        const childBBox = node.leaf ? toBBox(child) : child;
+        if (intersects(bbox, childBBox)) {
+          if (node.leaf)
+            result.push(child);
+          else if (contains(bbox, childBBox))
+            this._all(child, result);
+          else
+            nodesToSearch.push(child);
+        }
+      }
+      node = nodesToSearch.pop();
+    }
+    return result;
+  }
+  collides(bbox) {
+    let node = this.data;
+    if (!intersects(bbox, node))
+      return false;
+    const nodesToSearch = [];
+    while (node) {
+      for (let i = 0;i < node.children.length; i++) {
+        const child = node.children[i];
+        const childBBox = node.leaf ? this.toBBox(child) : child;
+        if (intersects(bbox, childBBox)) {
+          if (node.leaf || contains(bbox, childBBox))
+            return true;
+          nodesToSearch.push(child);
+        }
+      }
+      node = nodesToSearch.pop();
+    }
+    return false;
+  }
+  load(data) {
+    if (!(data && data.length))
+      return this;
+    if (data.length < this._minEntries) {
+      for (let i = 0;i < data.length; i++) {
+        this.insert(data[i]);
+      }
+      return this;
+    }
+    let node = this._build(data.slice(), 0, data.length - 1, 0);
+    if (!this.data.children.length) {
+      this.data = node;
+    } else if (this.data.height === node.height) {
+      this._splitRoot(this.data, node);
+    } else {
+      if (this.data.height < node.height) {
+        const tmpNode = this.data;
+        this.data = node;
+        node = tmpNode;
+      }
+      this._insert(node, this.data.height - node.height - 1, true);
+    }
+    return this;
+  }
+  insert(item) {
+    if (item)
+      this._insert(item, this.data.height - 1);
+    return this;
+  }
+  clear() {
+    this.data = createNode([]);
+    return this;
+  }
+  remove(item, equalsFn) {
+    if (!item)
+      return this;
+    let node = this.data;
+    const bbox = this.toBBox(item);
+    const path42 = [];
+    const indexes = [];
+    let i, parent, goingUp;
+    while (node || path42.length) {
+      if (!node) {
+        node = path42.pop();
+        parent = path42[path42.length - 1];
+        i = indexes.pop();
+        goingUp = true;
+      }
+      if (node.leaf) {
+        const index = findItem(item, node.children, equalsFn);
+        if (index !== -1) {
+          node.children.splice(index, 1);
+          path42.push(node);
+          this._condense(path42);
+          return this;
+        }
+      }
+      if (!goingUp && !node.leaf && contains(node, bbox)) {
+        path42.push(node);
+        indexes.push(i);
+        i = 0;
+        parent = node;
+        node = node.children[0];
+      } else if (parent) {
+        i++;
+        node = parent.children[i];
+        goingUp = false;
+      } else
+        node = null;
+    }
+    return this;
+  }
+  toBBox(item) {
+    return item;
+  }
+  compareMinX(a, b) {
+    return a.minX - b.minX;
+  }
+  compareMinY(a, b) {
+    return a.minY - b.minY;
+  }
+  toJSON() {
+    return this.data;
+  }
+  fromJSON(data) {
+    this.data = data;
+    return this;
+  }
+  _all(node, result) {
+    const nodesToSearch = [];
+    while (node) {
+      if (node.leaf)
+        result.push(...node.children);
+      else
+        nodesToSearch.push(...node.children);
+      node = nodesToSearch.pop();
+    }
+    return result;
+  }
+  _build(items, left, right, height) {
+    const N = right - left + 1;
+    let M = this._maxEntries;
+    let node;
+    if (N <= M) {
+      node = createNode(items.slice(left, right + 1));
+      calcBBox(node, this.toBBox);
+      return node;
+    }
+    if (!height) {
+      height = Math.ceil(Math.log(N) / Math.log(M));
+      M = Math.ceil(N / Math.pow(M, height - 1));
+    }
+    node = createNode([]);
+    node.leaf = false;
+    node.height = height;
+    const N2 = Math.ceil(N / M);
+    const N1 = N2 * Math.ceil(Math.sqrt(M));
+    multiSelect(items, left, right, N1, this.compareMinX);
+    for (let i = left;i <= right; i += N1) {
+      const right2 = Math.min(i + N1 - 1, right);
+      multiSelect(items, i, right2, N2, this.compareMinY);
+      for (let j = i;j <= right2; j += N2) {
+        const right3 = Math.min(j + N2 - 1, right2);
+        node.children.push(this._build(items, j, right3, height - 1));
+      }
+    }
+    calcBBox(node, this.toBBox);
+    return node;
+  }
+  _chooseSubtree(bbox, node, level, path42) {
+    while (true) {
+      path42.push(node);
+      if (node.leaf || path42.length - 1 === level)
+        break;
+      let minArea = Infinity;
+      let minEnlargement = Infinity;
+      let targetNode;
+      for (let i = 0;i < node.children.length; i++) {
+        const child = node.children[i];
+        const area = bboxArea(child);
+        const enlargement = enlargedArea(bbox, child) - area;
+        if (enlargement < minEnlargement) {
+          minEnlargement = enlargement;
+          minArea = area < minArea ? area : minArea;
+          targetNode = child;
+        } else if (enlargement === minEnlargement) {
+          if (area < minArea) {
+            minArea = area;
+            targetNode = child;
+          }
+        }
+      }
+      node = targetNode || node.children[0];
+    }
+    return node;
+  }
+  _insert(item, level, isNode) {
+    const bbox = isNode ? item : this.toBBox(item);
+    const insertPath = [];
+    const node = this._chooseSubtree(bbox, this.data, level, insertPath);
+    node.children.push(item);
+    extend(node, bbox);
+    while (level >= 0) {
+      if (insertPath[level].children.length > this._maxEntries) {
+        this._split(insertPath, level);
+        level--;
+      } else
+        break;
+    }
+    this._adjustParentBBoxes(bbox, insertPath, level);
+  }
+  _split(insertPath, level) {
+    const node = insertPath[level];
+    const M = node.children.length;
+    const m = this._minEntries;
+    this._chooseSplitAxis(node, m, M);
+    const splitIndex = this._chooseSplitIndex(node, m, M);
+    const newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));
+    newNode.height = node.height;
+    newNode.leaf = node.leaf;
+    calcBBox(node, this.toBBox);
+    calcBBox(newNode, this.toBBox);
+    if (level)
+      insertPath[level - 1].children.push(newNode);
+    else
+      this._splitRoot(node, newNode);
+  }
+  _splitRoot(node, newNode) {
+    this.data = createNode([node, newNode]);
+    this.data.height = node.height + 1;
+    this.data.leaf = false;
+    calcBBox(this.data, this.toBBox);
+  }
+  _chooseSplitIndex(node, m, M) {
+    let index;
+    let minOverlap = Infinity;
+    let minArea = Infinity;
+    for (let i = m;i <= M - m; i++) {
+      const bbox1 = distBBox(node, 0, i, this.toBBox);
+      const bbox2 = distBBox(node, i, M, this.toBBox);
+      const overlap = intersectionArea(bbox1, bbox2);
+      const area = bboxArea(bbox1) + bboxArea(bbox2);
+      if (overlap < minOverlap) {
+        minOverlap = overlap;
+        index = i;
+        minArea = area < minArea ? area : minArea;
+      } else if (overlap === minOverlap) {
+        if (area < minArea) {
+          minArea = area;
+          index = i;
+        }
+      }
+    }
+    return index || M - m;
+  }
+  _chooseSplitAxis(node, m, M) {
+    const compareMinX = node.leaf ? this.compareMinX : compareNodeMinX;
+    const compareMinY = node.leaf ? this.compareMinY : compareNodeMinY;
+    const xMargin = this._allDistMargin(node, m, M, compareMinX);
+    const yMargin = this._allDistMargin(node, m, M, compareMinY);
+    if (xMargin < yMargin)
+      node.children.sort(compareMinX);
+  }
+  _allDistMargin(node, m, M, compare) {
+    node.children.sort(compare);
+    const toBBox = this.toBBox;
+    const leftBBox = distBBox(node, 0, m, toBBox);
+    const rightBBox = distBBox(node, M - m, M, toBBox);
+    let margin = bboxMargin(leftBBox) + bboxMargin(rightBBox);
+    for (let i = m;i < M - m; i++) {
+      const child = node.children[i];
+      extend(leftBBox, node.leaf ? toBBox(child) : child);
+      margin += bboxMargin(leftBBox);
+    }
+    for (let i = M - m - 1;i >= m; i--) {
+      const child = node.children[i];
+      extend(rightBBox, node.leaf ? toBBox(child) : child);
+      margin += bboxMargin(rightBBox);
+    }
+    return margin;
+  }
+  _adjustParentBBoxes(bbox, path42, level) {
+    for (let i = level;i >= 0; i--) {
+      extend(path42[i], bbox);
+    }
+  }
+  _condense(path42) {
+    for (let i = path42.length - 1, siblings;i >= 0; i--) {
+      if (path42[i].children.length === 0) {
+        if (i > 0) {
+          siblings = path42[i - 1].children;
+          siblings.splice(siblings.indexOf(path42[i]), 1);
+        } else
+          this.clear();
+      } else
+        calcBBox(path42[i], this.toBBox);
+    }
+  }
+}
+function findItem(item, items, equalsFn) {
+  if (!equalsFn)
+    return items.indexOf(item);
+  for (let i = 0;i < items.length; i++) {
+    if (equalsFn(item, items[i]))
+      return i;
+  }
+  return -1;
+}
+function calcBBox(node, toBBox) {
+  distBBox(node, 0, node.children.length, toBBox, node);
+}
+function distBBox(node, k, p, toBBox, destNode) {
+  if (!destNode)
+    destNode = createNode(null);
+  destNode.minX = Infinity;
+  destNode.minY = Infinity;
+  destNode.maxX = -Infinity;
+  destNode.maxY = -Infinity;
+  for (let i = k;i < p; i++) {
+    const child = node.children[i];
+    extend(destNode, node.leaf ? toBBox(child) : child);
+  }
+  return destNode;
+}
+function extend(a, b) {
+  a.minX = Math.min(a.minX, b.minX);
+  a.minY = Math.min(a.minY, b.minY);
+  a.maxX = Math.max(a.maxX, b.maxX);
+  a.maxY = Math.max(a.maxY, b.maxY);
+  return a;
+}
+function compareNodeMinX(a, b) {
+  return a.minX - b.minX;
+}
+function compareNodeMinY(a, b) {
+  return a.minY - b.minY;
+}
+function bboxArea(a) {
+  return (a.maxX - a.minX) * (a.maxY - a.minY);
+}
+function bboxMargin(a) {
+  return a.maxX - a.minX + (a.maxY - a.minY);
+}
+function enlargedArea(a, b) {
+  return (Math.max(b.maxX, a.maxX) - Math.min(b.minX, a.minX)) * (Math.max(b.maxY, a.maxY) - Math.min(b.minY, a.minY));
+}
+function intersectionArea(a, b) {
+  const minX = Math.max(a.minX, b.minX);
+  const minY = Math.max(a.minY, b.minY);
+  const maxX = Math.min(a.maxX, b.maxX);
+  const maxY = Math.min(a.maxY, b.maxY);
+  return Math.max(0, maxX - minX) * Math.max(0, maxY - minY);
+}
+function contains(a, b) {
+  return a.minX <= b.minX && a.minY <= b.minY && b.maxX <= a.maxX && b.maxY <= a.maxY;
+}
+function intersects(a, b) {
+  return b.minX <= a.maxX && b.minY <= a.maxY && b.maxX >= a.minX && b.maxY >= a.minY;
+}
+function createNode(children) {
+  return {
+    children,
+    height: 1,
+    leaf: true,
+    minX: Infinity,
+    minY: Infinity,
+    maxX: -Infinity,
+    maxY: -Infinity
+  };
+}
+function multiSelect(arr, left, right, n, compare) {
+  const stack = [left, right];
+  while (stack.length) {
+    right = stack.pop();
+    left = stack.pop();
+    if (right - left <= n)
+      continue;
+    const mid = left + Math.ceil((right - left) / n / 2) * n;
+    quickselect(arr, mid, left, right, compare);
+    stack.push(left, mid, mid, right);
+  }
+}
+
 // node_modules/@tscircuit/circuit-json-placement-analysis/dist/index.js
 var CENTER_ANCHOR = "center";
 var toNumber2 = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
@@ -112417,6 +112879,9 @@ var analyzeComponentPlacement = (circuitJson, componentName) => {
 };
 var TOP_ISSUE_LIMIT = 5;
 var CENTER_ANCHOR2 = "center";
+var LARGE_EMPTY_SPACE_THRESHOLD_RATIO = 0.05;
+var EMPTY_SPACE_SAMPLE_STEP_MM = 5;
+var GEOMETRY_EPSILON = 0.000001;
 var ISSUE_TYPE_ORDER = [
   "pad_overlap",
   "off_board",
@@ -112431,6 +112896,8 @@ var fmtNumber2 = (value) => {
   return value.toFixed(3).replace(/\.0+$/, "").replace(/(\.\d*?)0+$/, "$1");
 };
 var fmtMm2 = (value) => `${fmtNumber2(value)}mm`;
+var fmtArea = (value) => `${fmtNumber2(value)}mm^2`;
+var fmtPercent = (value) => `${fmtNumber2(value)}%`;
 var getBoundsFromCenterAndSize = (centerX, centerY, width, height) => ({
   min_x: centerX - width / 2,
   max_x: centerX + width / 2,
@@ -112476,6 +112943,22 @@ var getOverlap = (a, b) => {
     clearance: -Math.min(overlapX, overlapY)
   };
 };
+var getBoundsIntersection = (a, b) => {
+  const min_x = Math.max(a.min_x, b.min_x);
+  const max_x = Math.min(a.max_x, b.max_x);
+  const min_y = Math.max(a.min_y, b.min_y);
+  const max_y = Math.min(a.max_y, b.max_y);
+  if (min_x >= max_x || min_y >= max_y)
+    return null;
+  return {
+    min_x,
+    max_x,
+    min_y,
+    max_y,
+    width: max_x - min_x,
+    height: max_y - min_y
+  };
+};
 var layersIntersect = (a, b) => {
   const bSet = new Set(b);
   return a.some((layer) => bSet.has(layer));
@@ -112485,6 +112968,14 @@ var getArea = (bounds) => {
     return Number.POSITIVE_INFINITY;
   return bounds.width * bounds.height;
 };
+var toPlacementBounds = (bounds) => ({
+  width: bounds.width,
+  height: bounds.height,
+  min_x: bounds.min_x,
+  max_x: bounds.max_x,
+  min_y: bounds.min_y,
+  max_y: bounds.max_y
+});
 var stripNumericSuffix = (name) => {
   const stripped = name.replace(/\d+$/, "");
   return stripped.length >= 2 ? stripped : name;
@@ -112784,6 +113275,263 @@ var buildComponentContexts = (circuitJson) => {
     boardBounds
   };
 };
+var getTopCopperBounds = (component) => {
+  const topPadBounds = component.pads.filter((pad) => pad.layers.includes("top")).map((pad) => pad.bounds);
+  if (topPadBounds.length === 0)
+    return null;
+  return {
+    min_x: Math.min(...topPadBounds.map((bounds) => bounds.min_x)),
+    max_x: Math.max(...topPadBounds.map((bounds) => bounds.max_x)),
+    min_y: Math.min(...topPadBounds.map((bounds) => bounds.min_y)),
+    max_y: Math.max(...topPadBounds.map((bounds) => bounds.max_y)),
+    width: Math.max(...topPadBounds.map((bounds) => bounds.max_x)) - Math.min(...topPadBounds.map((bounds) => bounds.min_x)),
+    height: Math.max(...topPadBounds.map((bounds) => bounds.max_y)) - Math.min(...topPadBounds.map((bounds) => bounds.min_y))
+  };
+};
+var getTopOccupancyBounds = (component) => {
+  if (component.layer !== "top")
+    return [];
+  if (component.courtyards.length > 0)
+    return component.courtyards;
+  const topCopperBounds = getTopCopperBounds(component);
+  return topCopperBounds ? [topCopperBounds] : [];
+};
+var getUniqueSortedCoordinates = (values) => [...new Set(values)].sort((a, b) => a - b);
+var createBounds = (min_x, max_x, min_y, max_y) => ({
+  min_x,
+  max_x,
+  min_y,
+  max_y,
+  width: max_x - min_x,
+  height: max_y - min_y
+});
+var pointIsInsideBounds = (x, y, bounds) => x > bounds.min_x + GEOMETRY_EPSILON && x < bounds.max_x - GEOMETRY_EPSILON && y > bounds.min_y + GEOMETRY_EPSILON && y < bounds.max_y - GEOMETRY_EPSILON;
+var buildFlatbushIndex = (boundsList) => {
+  if (boundsList.length === 0)
+    return null;
+  const index = new Flatbush(boundsList.length);
+  for (const bounds of boundsList) {
+    index.add(bounds.min_x, bounds.min_y, bounds.max_x, bounds.max_y);
+  }
+  index.finish();
+  return index;
+};
+var boundsOverlapWithArea = (a, b) => getBoundsIntersection(a, b) !== null;
+var isBoundsEmpty = (bounds, occupiedBounds, occupiedIndex) => {
+  if (bounds.width <= GEOMETRY_EPSILON || bounds.height <= GEOMETRY_EPSILON) {
+    return true;
+  }
+  const candidates = occupiedIndex ? occupiedIndex.search(bounds.min_x, bounds.min_y, bounds.max_x, bounds.max_y) : occupiedBounds.map((_, index) => index);
+  return !candidates.some((candidateIndex) => boundsOverlapWithArea(bounds, occupiedBounds[candidateIndex]));
+};
+var isPointOccupied = (x, y, occupiedBounds, occupiedIndex) => {
+  const candidates = occupiedIndex ? occupiedIndex.search(x, y, x, y) : occupiedBounds.map((_, index) => index);
+  return candidates.some((candidateIndex) => pointIsInsideBounds(x, y, occupiedBounds[candidateIndex]));
+};
+var getSampleAxisValues = (min, max, step) => {
+  const values = /* @__PURE__ */ new Set([min, max]);
+  let current = min;
+  while (current < max - GEOMETRY_EPSILON) {
+    const next = Math.min(current + step, max);
+    values.add(current);
+    values.add((current + next) / 2);
+    values.add(next);
+    current = next;
+  }
+  return [...values].sort((a, b) => a - b);
+};
+var getExpansionDelta = (bounds, boardBounds, direction, occupiedBounds, occupiedIndex) => {
+  const searchIndices = (() => {
+    switch (direction) {
+      case "left":
+        return occupiedIndex ? occupiedIndex.search(boardBounds.min_x, bounds.min_y, bounds.min_x, bounds.max_y) : occupiedBounds.map((_, index) => index);
+      case "right":
+        return occupiedIndex ? occupiedIndex.search(bounds.max_x, bounds.min_y, boardBounds.max_x, bounds.max_y) : occupiedBounds.map((_, index) => index);
+      case "up":
+        return occupiedIndex ? occupiedIndex.search(bounds.min_x, boardBounds.min_y, bounds.max_x, bounds.min_y) : occupiedBounds.map((_, index) => index);
+      case "down":
+        return occupiedIndex ? occupiedIndex.search(bounds.min_x, bounds.max_y, bounds.max_x, boardBounds.max_y) : occupiedBounds.map((_, index) => index);
+    }
+  })();
+  const overlappingCandidates = searchIndices.map((index) => occupiedBounds[index]).filter((candidate) => {
+    if (direction === "left" || direction === "right") {
+      return Math.min(bounds.max_y, candidate.max_y) - Math.max(bounds.min_y, candidate.min_y) > GEOMETRY_EPSILON;
+    }
+    return Math.min(bounds.max_x, candidate.max_x) - Math.max(bounds.min_x, candidate.min_x) > GEOMETRY_EPSILON;
+  });
+  switch (direction) {
+    case "left":
+      return Math.max(0, Math.min(bounds.min_x - boardBounds.min_x, ...overlappingCandidates.filter((candidate) => candidate.max_x <= bounds.min_x + GEOMETRY_EPSILON).map((candidate) => bounds.min_x - candidate.max_x)));
+    case "right":
+      return Math.max(0, Math.min(boardBounds.max_x - bounds.max_x, ...overlappingCandidates.filter((candidate) => candidate.min_x >= bounds.max_x - GEOMETRY_EPSILON).map((candidate) => candidate.min_x - bounds.max_x)));
+    case "up":
+      return Math.max(0, Math.min(bounds.min_y - boardBounds.min_y, ...overlappingCandidates.filter((candidate) => candidate.max_y <= bounds.min_y + GEOMETRY_EPSILON).map((candidate) => bounds.min_y - candidate.max_y)));
+    case "down":
+      return Math.max(0, Math.min(boardBounds.max_y - bounds.max_y, ...overlappingCandidates.filter((candidate) => candidate.min_y >= bounds.max_y - GEOMETRY_EPSILON).map((candidate) => candidate.min_y - bounds.max_y)));
+  }
+};
+var expandBounds = (bounds, direction, delta) => {
+  switch (direction) {
+    case "left":
+      return createBounds(bounds.min_x - delta, bounds.max_x, bounds.min_y, bounds.max_y);
+    case "right":
+      return createBounds(bounds.min_x, bounds.max_x + delta, bounds.min_y, bounds.max_y);
+    case "up":
+      return createBounds(bounds.min_x, bounds.max_x, bounds.min_y - delta, bounds.max_y);
+    case "down":
+      return createBounds(bounds.min_x, bounds.max_x, bounds.min_y, bounds.max_y + delta);
+  }
+};
+var growBoundsInDirection = (initialBounds, boardBounds, occupiedBounds, occupiedIndex, direction) => {
+  const delta = getExpansionDelta(initialBounds, boardBounds, direction, occupiedBounds, occupiedIndex);
+  if (delta <= GEOMETRY_EPSILON)
+    return initialBounds;
+  const nextBounds = expandBounds(initialBounds, direction, delta);
+  return isBoundsEmpty(nextBounds, occupiedBounds, occupiedIndex) ? nextBounds : initialBounds;
+};
+var growRectangleFully = (initialBounds, boardBounds, occupiedBounds, occupiedIndex) => {
+  let currentBounds = initialBounds;
+  while (true) {
+    const candidates = ["left", "right", "up", "down"].map((direction) => {
+      const delta = getExpansionDelta(currentBounds, boardBounds, direction, occupiedBounds, occupiedIndex);
+      if (delta <= GEOMETRY_EPSILON)
+        return null;
+      const nextBounds = expandBounds(currentBounds, direction, delta);
+      if (!isBoundsEmpty(nextBounds, occupiedBounds, occupiedIndex))
+        return null;
+      return {
+        direction,
+        bounds: nextBounds,
+        area: nextBounds.width * nextBounds.height
+      };
+    }).filter((candidate) => Boolean(candidate)).sort((a, b) => {
+      if (b.area !== a.area)
+        return b.area - a.area;
+      return a.direction.localeCompare(b.direction);
+    });
+    const bestCandidate = candidates[0];
+    if (!bestCandidate)
+      return currentBounds;
+    currentBounds = bestCandidate.bounds;
+  }
+};
+var getLargestEmptySpaceFromPoint = (x, y, boardBounds, occupiedBounds, occupiedIndex) => {
+  if (isPointOccupied(x, y, occupiedBounds, occupiedIndex))
+    return null;
+  const horizontalSpan = [
+    "left",
+    "right"
+  ].reduce((bounds, direction) => growBoundsInDirection(bounds, boardBounds, occupiedBounds, occupiedIndex, direction), createBounds(x, x, y - GEOMETRY_EPSILON, y + GEOMETRY_EPSILON));
+  const verticalSpan = [
+    "up",
+    "down"
+  ].reduce((bounds, direction) => growBoundsInDirection(bounds, boardBounds, occupiedBounds, occupiedIndex, direction), createBounds(x - GEOMETRY_EPSILON, x + GEOMETRY_EPSILON, y, y));
+  const horizontalFirst = growRectangleFully(["up", "down"].reduce((bounds, direction) => growBoundsInDirection(bounds, boardBounds, occupiedBounds, occupiedIndex, direction), horizontalSpan), boardBounds, occupiedBounds, occupiedIndex);
+  const verticalFirst = growRectangleFully(["left", "right"].reduce((bounds, direction) => growBoundsInDirection(bounds, boardBounds, occupiedBounds, occupiedIndex, direction), verticalSpan), boardBounds, occupiedBounds, occupiedIndex);
+  const horizontalArea = horizontalFirst.width * horizontalFirst.height;
+  const verticalArea = verticalFirst.width * verticalFirst.height;
+  if (horizontalArea <= GEOMETRY_EPSILON && verticalArea <= GEOMETRY_EPSILON) {
+    return null;
+  }
+  return horizontalArea >= verticalArea ? horizontalFirst : verticalFirst;
+};
+var createEmptySpaceIndexItem = (bounds, boardArea, sequenceNumber) => {
+  const area = bounds.width * bounds.height;
+  return {
+    id: `empty-space-${sequenceNumber}`,
+    minX: bounds.min_x,
+    minY: bounds.min_y,
+    maxX: bounds.max_x,
+    maxY: bounds.max_y,
+    area,
+    areaPercent: boardArea === 0 ? 0 : area / boardArea * 100,
+    bounds: toPlacementBounds(bounds)
+  };
+};
+var buildLargeEmptySpaces = (boardBounds, occupiedBounds, occupiedIndex, boardArea, thresholdArea) => {
+  const emptySpaceIndex = new RBush;
+  const sampleXs = getSampleAxisValues(boardBounds.min_x, boardBounds.max_x, EMPTY_SPACE_SAMPLE_STEP_MM);
+  const sampleYs = getSampleAxisValues(boardBounds.min_y, boardBounds.max_y, EMPTY_SPACE_SAMPLE_STEP_MM);
+  let sequenceNumber = 0;
+  for (const y of sampleYs) {
+    for (const x of sampleXs) {
+      const bounds = getLargestEmptySpaceFromPoint(x, y, boardBounds, occupiedBounds, occupiedIndex);
+      if (!bounds)
+        continue;
+      const area = bounds.width * bounds.height;
+      if (area <= thresholdArea)
+        continue;
+      const candidate = createEmptySpaceIndexItem(bounds, boardArea, sequenceNumber++);
+      const overlappingSpaces = emptySpaceIndex.search(candidate).filter((space) => boundsOverlapWithArea(bounds, createBounds(space.minX, space.maxX, space.minY, space.maxY)));
+      if (overlappingSpaces.some((space) => space.area >= candidate.area)) {
+        continue;
+      }
+      for (const overlappingSpace of overlappingSpaces) {
+        emptySpaceIndex.remove(overlappingSpace);
+      }
+      emptySpaceIndex.insert(candidate);
+    }
+  }
+  return emptySpaceIndex.all().map(({ area, areaPercent, bounds }) => ({
+    area,
+    areaPercent,
+    bounds
+  })).sort((a, b) => {
+    if (b.area !== a.area)
+      return b.area - a.area;
+    if (a.bounds.min_y !== b.bounds.min_y) {
+      return a.bounds.min_y - b.bounds.min_y;
+    }
+    return a.bounds.min_x - b.bounds.min_x;
+  });
+};
+var buildBoardTopLayerReport = (components, boardBounds) => {
+  if (!boardBounds)
+    return null;
+  const boardArea = boardBounds.width * boardBounds.height;
+  const largeEmptySpaceThresholdArea = boardArea * LARGE_EMPTY_SPACE_THRESHOLD_RATIO;
+  const occupancyBounds = components.flatMap((component) => getTopOccupancyBounds(component).map((bounds) => getBoundsIntersection(bounds, boardBounds)).filter((bounds) => Boolean(bounds)));
+  const occupiedIndex = buildFlatbushIndex(occupancyBounds);
+  const xCoords = getUniqueSortedCoordinates([
+    boardBounds.min_x,
+    boardBounds.max_x,
+    ...occupancyBounds.flatMap((bounds) => [bounds.min_x, bounds.max_x])
+  ]);
+  const yCoords = getUniqueSortedCoordinates([
+    boardBounds.min_y,
+    boardBounds.max_y,
+    ...occupancyBounds.flatMap((bounds) => [bounds.min_y, bounds.max_y])
+  ]);
+  const occupied = [];
+  let occupiedArea = 0;
+  for (let yi = 0;yi < yCoords.length - 1; yi += 1) {
+    const row = [];
+    for (let xi = 0;xi < xCoords.length - 1; xi += 1) {
+      const cellBounds = {
+        min_x: xCoords[xi],
+        max_x: xCoords[xi + 1],
+        min_y: yCoords[yi],
+        max_y: yCoords[yi + 1],
+        width: xCoords[xi + 1] - xCoords[xi],
+        height: yCoords[yi + 1] - yCoords[yi]
+      };
+      const candidateIndices = occupiedIndex ? occupiedIndex.search(cellBounds.min_x, cellBounds.min_y, cellBounds.max_x, cellBounds.max_y) : occupancyBounds.map((_, index) => index);
+      const isOccupied = candidateIndices.some((candidateIndex) => boundsOverlapWithArea(cellBounds, occupancyBounds[candidateIndex]));
+      row.push(isOccupied);
+      if (isOccupied)
+        occupiedArea += cellBounds.width * cellBounds.height;
+    }
+    occupied.push(row);
+  }
+  const largeEmptySpaces = buildLargeEmptySpaces(boardBounds, occupancyBounds, occupiedIndex, boardArea, largeEmptySpaceThresholdArea);
+  return {
+    boardArea,
+    occupiedArea,
+    utilizationPercent: boardArea === 0 ? 0 : occupiedArea / boardArea * 100,
+    largeEmptySpaceThresholdArea,
+    largeEmptySpaces
+  };
+};
 var buildIssues = (components, boardBounds) => {
   const issues = [];
   for (const component of components) {
@@ -113000,6 +113748,7 @@ var formatSourcePlacement = (component) => {
   }
   return bits.join(", ");
 };
+var formatBounds = (bounds) => `bounds=(minX=${fmtMm2(bounds.min_x)}, maxX=${fmtMm2(bounds.max_x)}, minY=${fmtMm2(bounds.min_y)}, maxY=${fmtMm2(bounds.max_y)})`;
 var formatResolvedPlacement = (component) => {
   const bits = [];
   const center = component.resolvedPlacement.center;
@@ -113008,7 +113757,7 @@ var formatResolvedPlacement = (component) => {
     bits.push(`center=(${fmtMm2(center.x)}, ${fmtMm2(center.y)}) on ${center.layer}`);
   }
   if (bounds) {
-    bits.push(`bounds=(minX=${fmtMm2(bounds.min_x)}, maxX=${fmtMm2(bounds.max_x)}, minY=${fmtMm2(bounds.min_y)}, maxY=${fmtMm2(bounds.max_y)})`);
+    bits.push(formatBounds(bounds));
     bits.push(`size=(width=${fmtMm2(bounds.width)}, height=${fmtMm2(bounds.height)})`);
   }
   bits.push(`anchor_alignment="${component.resolvedPlacement.anchorAlignment}"`);
@@ -113039,6 +113788,20 @@ var formatPlacementAnalysisReport = (report) => {
       lines.push(`- ${cluster.clusterName}: ${cluster.componentNames.join(", ")}`);
     }
   }
+  if (report.boardTopLayer) {
+    const emptySpaceThresholdPercent = report.boardTopLayer.boardArea === 0 ? 0 : report.boardTopLayer.largeEmptySpaceThresholdArea / report.boardTopLayer.boardArea * 100;
+    lines.push("");
+    lines.push("board top-layer utilization:");
+    lines.push(`- occupied: ${fmtPercent(report.boardTopLayer.utilizationPercent)} (${fmtArea(report.boardTopLayer.occupiedArea)} of ${fmtArea(report.boardTopLayer.boardArea)})`);
+    if (report.boardTopLayer.largeEmptySpaces.length > 0) {
+      lines.push(`- empty spaces over ${fmtPercent(emptySpaceThresholdPercent)} of board area:`);
+      for (const emptySpace of report.boardTopLayer.largeEmptySpaces) {
+        lines.push(`  - ${fmtPercent(emptySpace.areaPercent)} (${fmtArea(emptySpace.area)}); ${formatBounds(emptySpace.bounds)}`);
+      }
+    } else {
+      lines.push(`- empty spaces over ${fmtPercent(emptySpaceThresholdPercent)} of board area: none`);
+    }
+  }
   lines.push("");
   lines.push("board-edge status:");
   for (const component of report.components) {
@@ -113071,6 +113834,7 @@ var buildPlacementAnalysisReport = (circuitJson) => {
   const issues = buildIssues(components, boardBounds);
   const clusters = buildClusters(components, issues);
   const countsByType = buildCountsByType(issues);
+  const boardTopLayer = buildBoardTopLayerReport(components, boardBounds);
   return {
     summary: {
       totalIssueCount: issues.length,
@@ -113078,6 +113842,7 @@ var buildPlacementAnalysisReport = (circuitJson) => {
       topIssues: issues.slice(0, TOP_ISSUE_LIMIT),
       likelyBadClusters: clusters
     },
+    boardTopLayer,
     components: buildComponentStatuses(components, boardBounds, issues),
     issues
   };
@@ -113109,10 +113874,10 @@ var analyzeAllPlacements = (circuitJson) => {
 
 // cli/check/placement/register.ts
 import {
-  categorizeErrorOrWarning as categorizeErrorOrWarning2
+  categorizeErrorOrWarning as categorizeErrorOrWarning3
 } from "@tscircuit/circuit-json-util";
-var normalizeCategory2 = (category) => category === "netlist" || category === "pin_specification" || category === "placement" || category === "routing" ? category : "unknown";
-var isPlacementDiagnostic = (issue) => normalizeCategory2(categorizeErrorOrWarning2(issue)) === "placement";
+var normalizeCategory3 = (category) => category === "netlist" || category === "pin_specification" || category === "placement" || category === "routing" ? category : "unknown";
+var isPlacementDiagnostic = (issue) => normalizeCategory3(categorizeErrorOrWarning3(issue)) === "placement";
 var getIssueType = (issue) => issue.error_type ?? issue.warning_type ?? issue.type ?? "unknown_issue";
 var getScopedComponentIds = (circuitJson, refdes) => {
   const sourceComponentIds = new Set;
@@ -113210,8 +113975,8 @@ var registerCheck = (program2) => {
 
 // node_modules/@tscircuit/circuit-json-routing-analysis/dist/index.js
 init_chunk_SK323GHE();
-import Flatbush from "flatbush";
 import Flatbush2 from "flatbush";
+import Flatbush22 from "flatbush";
 import { webcrypto as crypto4 } from "crypto";
 import Flatbush3 from "flatbush";
 var require_object_hash = __commonJS2({
@@ -135515,7 +136280,7 @@ var require_is_extendable = __commonJS2({
 var require_extend_shallow = __commonJS2({
   "node_modules/extend-shallow/index.js"(exports2, module2) {
     var isObject22 = require_is_extendable();
-    module2.exports = function extend(o22) {
+    module2.exports = function extend2(o22) {
       if (!isObject22(o22)) {
         o22 = {};
       }
@@ -135543,10 +136308,10 @@ var require_extend_shallow = __commonJS2({
 var require_condense_newlines = __commonJS2({
   "node_modules/condense-newlines/index.js"(exports2, module2) {
     var isWhitespace2 = require_is_whitespace();
-    var extend = require_extend_shallow();
+    var extend2 = require_extend_shallow();
     var typeOf = require_kind_of();
     module2.exports = function(str, options) {
-      var opts = extend({}, options);
+      var opts = extend2({}, options);
       var sep = opts.sep || `
 
 `;
@@ -135596,7 +136361,7 @@ var require_pretty = __commonJS2({
   "node_modules/pretty/index.js"(exports2, module2) {
     var beautify = require_js();
     var condense = require_condense_newlines();
-    var extend = require_extend_shallow();
+    var extend2 = require_extend_shallow();
     var defaults = {
       unformatted: ["code", "pre", "em", "strong", "span"],
       indent_inner_html: true,
@@ -135606,7 +136371,7 @@ var require_pretty = __commonJS2({
 `
     };
     module2.exports = function pretty2(str, options) {
-      var opts = extend({}, defaults, options);
+      var opts = extend2({}, defaults, options);
       str = beautify.html(str, opts);
       if (opts.ocd === true) {
         if (opts.newlines)
@@ -135921,7 +136686,7 @@ var translateBounds = (bounds, direction2, distance7) => {
 var MAX_FREE_SPACE_MM = 5;
 var BINARY_SEARCH_ITERATIONS = 10;
 var buildComponentSpatialIndex = (components) => {
-  const index = new Flatbush(components.length);
+  const index = new Flatbush2(components.length);
   for (const component of components) {
     index.add(component.bounds.minX, component.bounds.minY, component.bounds.maxX, component.bounds.maxY);
   }
@@ -136848,7 +137613,7 @@ var require_reader4 = __commonJS22({
       element: "element",
       text: "text"
     };
-    var createNode = function createNode2(params2) {
+    var createNode2 = function createNode22(params2) {
       return Object.assign({
         name: "",
         type: NodeType.element,
@@ -136876,7 +137641,7 @@ var require_reader4 = __commonJS22({
               current2 = rootNode;
               current2.name = data.value;
             } else {
-              var node = createNode({
+              var node = createNode2({
                 name: data.value,
                 parent: current2
               });
@@ -136909,7 +137674,7 @@ var require_reader4 = __commonJS22({
             break;
           case Type.text:
             if (current2) {
-              current2.children.push(createNode({
+              current2.children.push(createNode2({
                 type: NodeType.text,
                 value: data.value,
                 parent: options.parentNodes ? current2 : null
@@ -136928,7 +137693,7 @@ var require_reader4 = __commonJS22({
       reader.reset = function() {
         lexer = Lexer.create({ debug: options.debug });
         lexer.on("data", handleLexerData);
-        rootNode = createNode();
+        rootNode = createNode2();
         current2 = null;
         attrName = "";
         reader.parse = lexer.write;
@@ -171024,8 +171789,8 @@ var isPointInsidePolygon = (point5, polygon2) => {
     const yi22 = polygon2[i2].y;
     const xj = polygon2[j22].x;
     const yj = polygon2[j22].y;
-    const intersects = yi22 > point5.y !== yj > point5.y && point5.x < (xj - xi22) * (point5.y - yi22) / (yj - yi22) + xi22;
-    if (intersects) {
+    const intersects2 = yi22 > point5.y !== yj > point5.y && point5.x < (xj - xi22) * (point5.y - yi22) / (yj - yi22) + xi22;
+    if (intersects2) {
       inside2 = !inside2;
     }
   }
@@ -192678,7 +193443,7 @@ function getChildFunc(next, adapter) {
 }
 var filters = {
   contains(next, text, { adapter }) {
-    return function contains(elem) {
+    return function contains2(elem) {
       return next(elem) && adapter.getText(elem).includes(text);
     };
   },
@@ -194911,7 +195676,7 @@ var DE9IM = class {
   }
 };
 function ray_shoot(polygon2, point5) {
-  let contains = undefined;
+  let contains2 = undefined;
   let ray2 = new Flatten.Ray(point5);
   let line2 = new Flatten.Line(ray2.pt, ray2.norm);
   const searchBox = new Flatten.Box(ray2.box.xmin - Flatten.DP_TOL, ray2.box.ymin - Flatten.DP_TOL, ray2.box.xmax + Flatten.DP_TOL, ray2.box.ymax + Flatten.DP_TOL);
@@ -195010,8 +195775,8 @@ function ray_shoot(polygon2, point5) {
       }
     }
   }
-  contains = counter % 2 === 1 ? INSIDE$2 : OUTSIDE$1;
-  return contains;
+  contains2 = counter % 2 === 1 ? INSIDE$2 : OUTSIDE$1;
+  return contains2;
 }
 function equal(shape1, shape2) {
   return relate(shape1, shape2).equal();
@@ -200377,23 +201142,23 @@ function computeOverlapDistance(compPoly, boardPoly, componentCenter, componentW
   }
   try {
     const intersection = BooleanOperations.intersect(compPoly, boardPoly);
-    let intersectionArea = 0;
+    let intersectionArea2 = 0;
     if (!intersection) {
-      intersectionArea = 0;
+      intersectionArea2 = 0;
     } else if (Array.isArray(intersection)) {
-      intersectionArea = intersection.reduce((sum, p3) => sum + (typeof p3.area === "function" ? p3.area() : 0), 0);
+      intersectionArea2 = intersection.reduce((sum, p3) => sum + (typeof p3.area === "function" ? p3.area() : 0), 0);
     } else if (typeof intersection.area === "function") {
-      intersectionArea = intersection.area();
+      intersectionArea2 = intersection.area();
     } else {
-      intersectionArea = 0;
+      intersectionArea2 = 0;
     }
     const compArea = compPoly.area();
-    if (intersectionArea > 0 && intersectionArea < compArea) {
-      const overlapRatio = 1 - intersectionArea / compArea;
+    if (intersectionArea2 > 0 && intersectionArea2 < compArea) {
+      const overlapRatio = 1 - intersectionArea2 / compArea;
       const compWidth = Math.abs(componentWidth);
       const compHeight = Math.abs(componentHeight);
       return Math.min(compWidth, compHeight) * overlapRatio;
-    } else if (intersectionArea === 0) {
+    } else if (intersectionArea2 === 0) {
       return 0.1;
     } else {
       return 0.1;
@@ -237108,8 +237873,8 @@ var isPointInRing = (point6, ring2) => {
   for (const current2 of ring2) {
     if (isPointOnSegment2(point6, previous, current2))
       return true;
-    const intersects = current2.y > point6.y !== previous.y > point6.y && point6.x < (previous.x - current2.x) * (point6.y - current2.y) / (previous.y - current2.y) + current2.x;
-    if (intersects)
+    const intersects2 = current2.y > point6.y !== previous.y > point6.y && point6.x < (previous.x - current2.x) * (point6.y - current2.y) / (previous.y - current2.y) + current2.x;
+    if (intersects2)
       inside2 = !inside2;
     previous = current2;
   }
@@ -239299,7 +240064,7 @@ var fmtNumber3 = (value) => {
   return value.toFixed(3).replace(/\.0+$/, "").replace(/(\.\d*?)0+$/, "$1");
 };
 var fmtMm22 = (value) => `${value.toFixed(1)}mm`;
-var fmtPercent = (value) => `${fmtNumber3(value * 100)}%`;
+var fmtPercent2 = (value) => `${fmtNumber3(value * 100)}%`;
 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));
@@ -239376,7 +240141,7 @@ var analyzeGlobalCapacityNodes = (nodes, circuitJson) => {
     const bounds = getBoundsFromNode(node);
     return {
       lineItemType: "CongestedRegion",
-      probabilityOfFailure: fmtPercent(getProbabilityOfFailure(node, maxDensity, maxPortPointCount)),
+      probabilityOfFailure: fmtPercent2(getProbabilityOfFailure(node, maxDensity, maxPortPointCount)),
       bounds,
       width: getBoundsWidth(bounds),
       height: getBoundsHeight(bounds),
@@ -239665,6 +240430,634 @@ var registerCheckRouting = (program2) => {
   });
 };
 
+// node_modules/circuit-json-trace-length-analysis/lib/analyze-circuit-json-trace-length.ts
+class Trace {
+  id;
+  label;
+  connectionType;
+  connectionTarget;
+  connectionTargetPosition;
+  connectedPins;
+  pinPositions;
+  requirements;
+  points;
+  lengthMm;
+  straightLineDistanceMm;
+  sourceTraceId;
+  displayName;
+  constructor(model) {
+    this.id = model.id;
+    this.label = model.label;
+    this.connectionType = model.connectionType;
+    this.connectionTarget = model.connectionTarget;
+    this.connectionTargetPosition = model.connectionTargetPosition;
+    this.connectedPins = model.connectedPins;
+    this.pinPositions = model.pinPositions;
+    this.requirements = model.requirements;
+    this.points = model.points;
+    this.lengthMm = model.lengthMm;
+    this.straightLineDistanceMm = model.straightLineDistanceMm;
+    this.sourceTraceId = model.sourceTraceId;
+    this.displayName = model.displayName;
+  }
+  toString() {
+    const lines = [
+      `<Trace id="${escapeXml(this.id)}" label="${escapeXml(this.label)}" connectionType="${escapeXml(this.connectionType)}" lengthMm="${formatNumber3(this.lengthMm)}" straightLineDistanceMm="${formatNumber3(this.straightLineDistanceMm)}">`,
+      `  <ConnectedPins>`,
+      ...this.connectedPins.map((pin) => `    <Pin ref="${escapeXml(pin.ref)}" />`),
+      `  </ConnectedPins>`,
+      `  <PinPositions>`,
+      ...this.pinPositions.map((pin) => renderPinPosition(pin, "    ")),
+      `  </PinPositions>`,
+      renderConnection(this),
+      renderRequirements(this.requirements, "  "),
+      `</Trace>`
+    ];
+    if (this.points.length > 0) {
+      lines.splice(lines.length - 1, 0, `  <Path>`, ...this.points.map((point5) => `    <Point x="${formatNumber3(point5.x)}" y="${formatNumber3(point5.y)}" layer="${escapeXml(point5.layer)}" kind="${escapeXml(point5.kind)}" />`), `  </Path>`);
+    }
+    return lines.join(`
+`);
+  }
+}
+
+class TraceLengthAnalysis {
+  requestedTarget;
+  resolvedTarget;
+  targetKind;
+  totalLengthMm;
+  totalStraightLineDistanceMm;
+  traceCount;
+  #traces;
+  constructor(args) {
+    this.requestedTarget = args.requestedTarget;
+    this.resolvedTarget = args.resolvedTarget;
+    this.targetKind = args.targetKind;
+    this.#traces = [...args.traces];
+    this.totalLengthMm = this.#traces.reduce((sum, trace) => sum + trace.lengthMm, 0);
+    this.totalStraightLineDistanceMm = this.#traces.reduce((sum, trace) => sum + trace.straightLineDistanceMm, 0);
+    this.traceCount = this.#traces.length;
+  }
+  listTraces() {
+    return [...this.#traces];
+  }
+  toString() {
+    const lines = [
+      `<TraceLengthAnalysis requestedTarget="${escapeXml(this.requestedTarget)}" resolvedTarget="${escapeXml(this.resolvedTarget)}" targetKind="${escapeXml(this.targetKind)}" traceCount="${this.traceCount}" totalLengthMm="${formatNumber3(this.totalLengthMm)}" totalStraightLineDistanceMm="${formatNumber3(this.totalStraightLineDistanceMm)}">`,
+      ...this.#traces.flatMap((trace) => trace.toString().split(`
+`).map((line2) => `  ${line2}`)),
+      `</TraceLengthAnalysis>`
+    ];
+    return lines.join(`
+`);
+  }
+}
+function analyzeCircuitJsonTraceLength(circuitJson, options) {
+  const index = new CircuitJsonIndex(circuitJson);
+  const target = resolveTarget(index, options.targetPinOrNet);
+  const traces = target.kind === "pin" ? collectPinTraces(index, target) : collectNetTraces(index, target);
+  return new TraceLengthAnalysis({
+    requestedTarget: target.requestedTarget,
+    resolvedTarget: target.resolvedTarget,
+    targetKind: target.kind,
+    traces
+  });
+}
+
+class CircuitJsonIndex {
+  componentsById = new Map;
+  componentsByName = new Map;
+  portsById = new Map;
+  portsByComponentId = new Map;
+  netsById = new Map;
+  netsByName = new Map;
+  pcbPortsBySourcePortId = new Map;
+  pcbTracesBySourceTraceId = new Map;
+  pcbTracesByConnectionName = new Map;
+  tracesById = new Map;
+  tracesByPortId = new Map;
+  tracesByNetId = new Map;
+  constructor(circuitJson) {
+    for (const item of circuitJson) {
+      switch (item.type) {
+        case "source_component":
+          this.addComponent(item);
+          break;
+        case "source_port":
+          this.addPort(item);
+          break;
+        case "source_net":
+          this.addNet(item);
+          break;
+        case "pcb_port":
+          this.addPcbPort(item);
+          break;
+        case "pcb_trace":
+          this.addPcbTrace(item);
+          break;
+        case "source_trace":
+          this.addTrace(item);
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  getComponentByName(name) {
+    return this.lookupWithCaseFallback(this.componentsByName, name);
+  }
+  getNetByName(name) {
+    return this.lookupWithCaseFallback(this.netsByName, name);
+  }
+  getPcbPort(sourcePortId) {
+    return this.pcbPortsBySourcePortId.get(sourcePortId)?.[0];
+  }
+  getPortPosition(sourcePortId) {
+    const pcbPort = this.getPcbPort(sourcePortId);
+    if (!pcbPort || typeof pcbPort.x !== "number" || typeof pcbPort.y !== "number") {
+      return null;
+    }
+    const layers = normalizeLayers(pcbPort.layers);
+    return {
+      x: pcbPort.x,
+      y: pcbPort.y,
+      layers
+    };
+  }
+  getPortReference(sourcePortId) {
+    const port = this.portsById.get(sourcePortId);
+    if (!port) {
+      return sourcePortId;
+    }
+    const component = this.componentsById.get(port.source_component_id);
+    const componentName = component?.name ?? port.source_component_id;
+    const portName = port.name ?? String(port.pin_number ?? port.source_port_id);
+    return `${componentName}.${portName}`;
+  }
+  getPcbPathPoints(sourceTraceId) {
+    const candidates = dedupePcbTraces([
+      ...this.pcbTracesBySourceTraceId.get(sourceTraceId) ?? [],
+      ...this.pcbTracesByConnectionName.get(sourceTraceId) ?? []
+    ]);
+    const pcbTraceIds = new Set(candidates.map((trace) => trace.pcb_trace_id));
+    if (candidates.length === 0 || pcbTraceIds.size > 1) {
+      return [];
+    }
+    const routePoints = candidates.flatMap((trace) => normalizePcbTraceRoute(trace));
+    return convertPcbTraceRouteToPath(routePoints);
+  }
+  getConnectedPinsForNet(sourceNetId) {
+    const traces = this.tracesByNetId.get(sourceNetId) ?? [];
+    const sourcePortIds = new Set;
+    for (const trace of traces) {
+      for (const sourcePortId of trace.connected_source_port_ids ?? []) {
+        sourcePortIds.add(sourcePortId);
+      }
+    }
+    return [...sourcePortIds].map((sourcePortId) => this.toConnectedPin(sourcePortId));
+  }
+  toConnectedPin(sourcePortId) {
+    const position2 = this.getPortPosition(sourcePortId);
+    return {
+      ref: this.getPortReference(sourcePortId),
+      x: position2?.x ?? null,
+      y: position2?.y ?? null,
+      layers: position2?.layers ?? []
+    };
+  }
+  addComponent(component) {
+    this.componentsById.set(component.source_component_id, component);
+    const name = component.name;
+    if (!name) {
+      return;
+    }
+    this.addLookup(this.componentsByName, name, component);
+  }
+  addPort(port) {
+    this.portsById.set(port.source_port_id, port);
+    this.addLookup(this.portsByComponentId, port.source_component_id, port);
+  }
+  addNet(net) {
+    this.netsById.set(net.source_net_id, net);
+    const name = net.name;
+    if (!name) {
+      return;
+    }
+    this.addLookup(this.netsByName, name, net);
+  }
+  addPcbPort(pcbPort) {
+    this.addLookup(this.pcbPortsBySourcePortId, pcbPort.source_port_id, pcbPort);
+  }
+  addPcbTrace(pcbTrace) {
+    if (pcbTrace.source_trace_id) {
+      this.addLookup(this.pcbTracesBySourceTraceId, pcbTrace.source_trace_id, pcbTrace);
+    }
+    if (pcbTrace.connection_name) {
+      this.addLookup(this.pcbTracesByConnectionName, pcbTrace.connection_name, pcbTrace);
+    }
+  }
+  addTrace(trace) {
+    this.tracesById.set(trace.source_trace_id, trace);
+    for (const sourcePortId of trace.connected_source_port_ids ?? []) {
+      this.addLookup(this.tracesByPortId, sourcePortId, trace);
+    }
+    for (const sourceNetId of trace.connected_source_net_ids ?? []) {
+      this.addLookup(this.tracesByNetId, sourceNetId, trace);
+    }
+  }
+  addLookup(map, key, value) {
+    const existing = map.get(key) ?? [];
+    existing.push(value);
+    map.set(key, existing);
+  }
+  lookupWithCaseFallback(map, key) {
+    const exactMatch = map.get(key);
+    if (exactMatch?.length) {
+      return exactMatch;
+    }
+    const loweredKey = key.toLowerCase();
+    const fuzzyMatches = [];
+    for (const [candidateKey, values] of map.entries()) {
+      if (candidateKey.toLowerCase() === loweredKey) {
+        fuzzyMatches.push(...values);
+      }
+    }
+    return fuzzyMatches;
+  }
+}
+function resolveTarget(index, targetPinOrNet) {
+  if (targetPinOrNet.includes(".")) {
+    if (targetPinOrNet.startsWith("net.")) {
+      const netName = targetPinOrNet.slice("net.".length);
+      const net = resolveNetByName(index, netName);
+      return {
+        kind: "net",
+        requestedTarget: targetPinOrNet,
+        resolvedTarget: `net.${net.name ?? net.source_net_id}`,
+        net
+      };
+    }
+    return resolvePinTarget(index, targetPinOrNet);
+  }
+  const matchingNet = resolveOptionalNetByName(index, targetPinOrNet);
+  if (matchingNet) {
+    const resolvedTarget = `net.${matchingNet.name ?? matchingNet.source_net_id}`;
+    console.log(`inferring ${resolvedTarget}`);
+    return {
+      kind: "net",
+      requestedTarget: targetPinOrNet,
+      resolvedTarget,
+      net: matchingNet
+    };
+  }
+  const matchingPin = resolveOptionalPinByLabel(index, targetPinOrNet);
+  if (matchingPin) {
+    const resolvedTarget = index.getPortReference(matchingPin.source_port_id);
+    console.log(`inferring ${resolvedTarget}`);
+    return {
+      kind: "pin",
+      requestedTarget: targetPinOrNet,
+      resolvedTarget,
+      port: matchingPin
+    };
+  }
+  throw new Error(`Unable to resolve target "${targetPinOrNet}" to a pin or net`);
+}
+function resolvePinTarget(index, targetPinOrNet) {
+  const [componentName, ...pinParts] = targetPinOrNet.split(".");
+  const pinLabelOrNumber = pinParts.join(".");
+  if (!componentName || !pinLabelOrNumber) {
+    throw new Error(`Invalid pin target "${targetPinOrNet}"`);
+  }
+  const components = index.getComponentByName(componentName);
+  if (components.length !== 1) {
+    throw new Error(components.length === 0 ? `Unable to find component "${componentName}"` : `Component "${componentName}" is ambiguous`);
+  }
+  const component = components[0];
+  if (!component) {
+    throw new Error(`Unable to find component "${componentName}"`);
+  }
+  const ports = index.portsByComponentId.get(component.source_component_id) ?? [];
+  const matchingPorts = ports.filter((port2) => portMatchesLabel(port2, pinLabelOrNumber));
+  if (matchingPorts.length !== 1) {
+    throw new Error(matchingPorts.length === 0 ? `Unable to find pin "${pinLabelOrNumber}" on ${componentName}` : `Pin "${pinLabelOrNumber}" on ${componentName} is ambiguous`);
+  }
+  const port = matchingPorts[0];
+  if (!port) {
+    throw new Error(`Unable to find pin "${pinLabelOrNumber}" on ${componentName}`);
+  }
+  return {
+    kind: "pin",
+    requestedTarget: targetPinOrNet,
+    resolvedTarget: index.getPortReference(port.source_port_id),
+    port
+  };
+}
+function resolveOptionalPinByLabel(index, pinLabelOrNumber) {
+  const matchingPorts = [...index.portsById.values()].filter((port) => portMatchesLabel(port, pinLabelOrNumber));
+  if (matchingPorts.length !== 1) {
+    return null;
+  }
+  return matchingPorts[0] ?? null;
+}
+function resolveNetByName(index, netName) {
+  const matchingNets = index.getNetByName(netName);
+  if (matchingNets.length !== 1) {
+    throw new Error(matchingNets.length === 0 ? `Unable to find net "${netName}"` : `Net "${netName}" is ambiguous`);
+  }
+  const net = matchingNets[0];
+  if (!net) {
+    throw new Error(`Unable to find net "${netName}"`);
+  }
+  return net;
+}
+function resolveOptionalNetByName(index, netName) {
+  const matchingNets = index.getNetByName(netName);
+  if (matchingNets.length !== 1) {
+    return null;
+  }
+  return matchingNets[0] ?? null;
+}
+function collectPinTraces(index, target) {
+  const traces = index.tracesByPortId.get(target.port.source_port_id) ?? [];
+  return traces.flatMap((trace) => {
+    const netIds = trace.connected_source_net_ids ?? [];
+    if (netIds.length > 0) {
+      return netIds.map((sourceNetId) => createNetTraceModel(index, {
+        trace,
+        sourceNetId,
+        focusSourcePortId: target.port.source_port_id
+      }));
+    }
+    return [
+      createDirectTraceModel(index, {
+        trace,
+        focusSourcePortId: target.port.source_port_id
+      })
+    ];
+  }).sort(compareTraceModels).map((model) => new Trace(model));
+}
+function collectNetTraces(index, target) {
+  const traces = index.tracesByNetId.get(target.net.source_net_id) ?? [];
+  return traces.flatMap((trace) => {
+    const connectedSourcePortIds = trace.connected_source_port_ids ?? [];
+    if (connectedSourcePortIds.length === 0) {
+      return [];
+    }
+    return connectedSourcePortIds.map((focusSourcePortId) => createNetTraceModel(index, {
+      trace,
+      sourceNetId: target.net.source_net_id,
+      focusSourcePortId
+    }));
+  }).sort(compareTraceModels).map((model) => new Trace(model));
+}
+function createDirectTraceModel(index, args) {
+  const connectedSourcePortIds = args.trace.connected_source_port_ids ?? [];
+  if (connectedSourcePortIds.length === 0) {
+    throw new Error(`Trace ${args.trace.source_trace_id} has no connected ports`);
+  }
+  const orderedPortIds = prioritizeFocus(connectedSourcePortIds, args.focusSourcePortId);
+  const firstPortId = orderedPortIds[0];
+  const secondPortId = orderedPortIds[1] ?? orderedPortIds[0];
+  if (!firstPortId || !secondPortId) {
+    throw new Error(`Trace ${args.trace.source_trace_id} is missing connected ports`);
+  }
+  const firstPosition = requirePortPosition(index, firstPortId);
+  const secondPosition = requirePortPosition(index, secondPortId);
+  const secondLayer = primaryLayer(secondPosition.layers);
+  const connectedPins = orderedPortIds.map((sourcePortId) => index.toConnectedPin(sourcePortId));
+  const connectionTarget4 = index.getPortReference(secondPortId);
+  const straightLineDistanceMm = distanceBetween(firstPosition, secondPosition);
+  const points = index.getPcbPathPoints(args.trace.source_trace_id);
+  const lengthMm = points.length > 1 ? measurePathLength(points) : straightLineDistanceMm;
+  return {
+    id: args.trace.source_trace_id,
+    label: `${index.getPortReference(firstPortId)} -> ${connectionTarget4}`,
+    connectionType: "direct connection",
+    connectionTarget: connectionTarget4,
+    connectionTargetPosition: {
+      x: secondPosition.x,
+      y: secondPosition.y,
+      layer: secondLayer
+    },
+    connectedPins,
+    pinPositions: connectedPins,
+    requirements: {
+      maxLengthMm: typeof args.trace.max_length === "number" ? args.trace.max_length : null
+    },
+    points,
+    lengthMm,
+    straightLineDistanceMm,
+    sourceTraceId: args.trace.source_trace_id,
+    displayName: args.trace.display_name ?? null
+  };
+}
+function createNetTraceModel(index, args) {
+  const net = index.netsById.get(args.sourceNetId);
+  if (!net) {
+    throw new Error(`Unable to find net ${args.sourceNetId}`);
+  }
+  const focusPosition = requirePortPosition(index, args.focusSourcePortId);
+  const focusLayer = primaryLayer(focusPosition.layers);
+  const connectedPins = index.getConnectedPinsForNet(args.sourceNetId).sort((a2, b) => a2.ref.localeCompare(b.ref));
+  const hub = inferNetHub(connectedPins, focusLayer);
+  const focusPin = index.toConnectedPin(args.focusSourcePortId);
+  const points = index.getPcbPathPoints(args.trace.source_trace_id);
+  const straightLineDistanceMm = distanceBetween(focusPosition, hub);
+  const lengthMm = points.length > 1 ? measurePathLength(points) : straightLineDistanceMm;
+  return {
+    id: `${args.trace.source_trace_id}:${args.focusSourcePortId}`,
+    label: `${focusPin.ref} -> net.${net.name ?? net.source_net_id}`,
+    connectionType: "via net",
+    connectionTarget: `net.${net.name ?? net.source_net_id}`,
+    connectionTargetPosition: hub,
+    connectedPins: prioritizePin(focusPin, connectedPins),
+    pinPositions: prioritizePin(focusPin, connectedPins),
+    requirements: {
+      maxLengthMm: typeof args.trace.max_length === "number" ? args.trace.max_length : null
+    },
+    points,
+    lengthMm,
+    straightLineDistanceMm,
+    sourceTraceId: args.trace.source_trace_id,
+    displayName: args.trace.display_name ?? null
+  };
+}
+function requirePortPosition(index, sourcePortId) {
+  const position2 = index.getPortPosition(sourcePortId);
+  if (!position2) {
+    throw new Error(`Unable to analyze ${index.getPortReference(sourcePortId)} because it has no pcb_port position`);
+  }
+  return position2;
+}
+function inferNetHub(connectedPins, fallbackLayer) {
+  const positionedPins = connectedPins.filter((pin) => typeof pin.x === "number" && typeof pin.y === "number");
+  if (positionedPins.length === 0) {
+    return {
+      x: 0,
+      y: 0,
+      layer: fallbackLayer
+    };
+  }
+  const x3 = positionedPins.reduce((sum, pin) => sum + pin.x, 0) / positionedPins.length;
+  const y4 = positionedPins.reduce((sum, pin) => sum + pin.y, 0) / positionedPins.length;
+  const layerCounts = new Map;
+  for (const pin of positionedPins) {
+    const layer2 = pin.layers[0] ?? fallbackLayer;
+    layerCounts.set(layer2, (layerCounts.get(layer2) ?? 0) + 1);
+  }
+  const sortedLayers = [...layerCounts.entries()].sort((left, right) => {
+    if (right[1] !== left[1]) {
+      return right[1] - left[1];
+    }
+    return left[0].localeCompare(right[0]);
+  });
+  const layer = sortedLayers[0]?.[0] ?? fallbackLayer;
+  return { x: x3, y: y4, layer };
+}
+function measurePathLength(points) {
+  let lengthMm = 0;
+  for (let index = 1;index < points.length; index += 1) {
+    const previous = points[index - 1];
+    const current2 = points[index];
+    if (!previous || !current2) {
+      continue;
+    }
+    lengthMm += distanceBetween(previous, current2);
+  }
+  return lengthMm;
+}
+function dedupePcbTraces(pcbTraces) {
+  const seen = new Set;
+  const deduped = [];
+  for (const pcbTrace of pcbTraces) {
+    if (seen.has(pcbTrace)) {
+      continue;
+    }
+    seen.add(pcbTrace);
+    deduped.push(pcbTrace);
+  }
+  return deduped;
+}
+function normalizePcbTraceRoute(pcbTrace) {
+  if (!Array.isArray(pcbTrace.route)) {
+    return [];
+  }
+  return pcbTrace.route.filter((point5) => typeof point5.x === "number" && typeof point5.y === "number").map((point5) => ({
+    ...point5,
+    layer: typeof point5.layer === "string" && point5.layer.length > 0 ? point5.layer : typeof pcbTrace.layer === "string" && pcbTrace.layer.length > 0 ? pcbTrace.layer : "top"
+  }));
+}
+function convertPcbTraceRouteToPath(routePoints) {
+  const deduped = routePoints.filter((point5, index) => {
+    const previous = routePoints[index - 1];
+    return !previous || previous.x !== point5.x || previous.y !== point5.y || previous.layer !== point5.layer;
+  });
+  return deduped.map((point5, index) => ({
+    x: point5.x,
+    y: point5.y,
+    layer: point5.layer,
+    kind: classifyPcbTracePoint(point5, index, deduped.length)
+  }));
+}
+function classifyPcbTracePoint(point5, index, pointCount) {
+  if (point5.route_type === "via") {
+    return "via";
+  }
+  if (index === 0 || index === pointCount - 1 || point5.start_pcb_port_id || point5.end_pcb_port_id) {
+    return "endpoint";
+  }
+  return "track";
+}
+function renderPinPosition(pin, indent) {
+  if (typeof pin.x !== "number" || typeof pin.y !== "number") {
+    return `${indent}<Pin ref="${escapeXml(pin.ref)}" position="unavailable" />`;
+  }
+  const layers = pin.layers.length > 0 ? pin.layers.join(",") : "unknown";
+  return `${indent}<Pin ref="${escapeXml(pin.ref)}" x="${formatNumber3(pin.x)}" y="${formatNumber3(pin.y)}" layers="${escapeXml(layers)}" />`;
+}
+function renderConnection(trace) {
+  if (trace.connectionTargetPosition) {
+    return `  <Connection kind="${escapeXml(trace.connectionType)}" target="${escapeXml(trace.connectionTarget)}" x="${formatNumber3(trace.connectionTargetPosition.x)}" y="${formatNumber3(trace.connectionTargetPosition.y)}" layer="${escapeXml(trace.connectionTargetPosition.layer)}" />`;
+  }
+  return `  <Connection kind="${escapeXml(trace.connectionType)}" target="${escapeXml(trace.connectionTarget)}" />`;
+}
+function renderRequirements(requirements, indent) {
+  if (typeof requirements.maxLengthMm === "number") {
+    return [
+      `${indent}<TraceRequirements>`,
+      `${indent}  <MaxLengthMm>${formatNumber3(requirements.maxLengthMm)}</MaxLengthMm>`,
+      `${indent}</TraceRequirements>`
+    ].join(`
+`);
+  }
+  return `${indent}<TraceRequirements none />`;
+}
+function portMatchesLabel(port, label) {
+  const loweredLabel = label.toLowerCase();
+  const portName = port.name?.toLowerCase();
+  const pinNumber = String(port.pin_number ?? "").toLowerCase();
+  const portHints2 = (port.port_hints ?? []).map((hint) => hint.toLowerCase());
+  return portName === loweredLabel || pinNumber === loweredLabel || portHints2.includes(loweredLabel);
+}
+function prioritizeFocus(portIds, focusSourcePortId) {
+  const remainder = portIds.filter((portId) => portId !== focusSourcePortId);
+  return [focusSourcePortId, ...remainder];
+}
+function prioritizePin(focusPin, pins) {
+  const remainder = pins.filter((pin) => pin.ref !== focusPin.ref);
+  return [focusPin, ...remainder];
+}
+function compareTraceModels(left, right) {
+  return left.label.localeCompare(right.label);
+}
+function normalizeLayers(layers) {
+  if (!Array.isArray(layers)) {
+    return ["top"];
+  }
+  const normalizedLayers = layers.filter((layer) => typeof layer === "string" && layer.length > 0);
+  return normalizedLayers.length > 0 ? normalizedLayers : ["top"];
+}
+function primaryLayer(layers) {
+  return layers[0] ?? "top";
+}
+function distanceBetween(left, right) {
+  return Math.hypot(right.x - left.x, right.y - left.y);
+}
+function formatNumber3(value) {
+  return value.toFixed(2);
+}
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+// cli/check/trace-length/register.ts
+var checkTraceLength = async (pinOrNetRef, file) => {
+  const resolvedInputFilePath = await resolveCheckInputFilePath(file);
+  const circuitJson = await getCircuitJsonForCheck({
+    filePath: resolvedInputFilePath,
+    platformConfig: {
+      pcbDisabled: false,
+      routingDisabled: false
+    },
+    allowPrebuiltCircuitJson: true
+  });
+  const analysis = analyzeCircuitJsonTraceLength(circuitJson, {
+    targetPinOrNet: pinOrNetRef
+  });
+  return analysis.toString();
+};
+var registerCheckTraceLength = (program2) => {
+  program2.commands.find((c3) => c3.name() === "check").command("trace-length").description("Analyze trace length for a pin or net").argument("<pinOrNetRef>", "Pin or net target to analyze").argument("[file]", "Path to the entry file").action(async (pinOrNetRef, file) => {
+    try {
+      const output = await checkTraceLength(pinOrNetRef, file);
+      console.log(output);
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+};
+
 // cli/clone/register.ts
 import * as fs43 from "node:fs";
 import * as path45 from "node:path";
@@ -270695,7 +272088,7 @@ var registerSetup = (program3) => {
 };
 
 // lib/shared/result-to-table.ts
-var formatNumber3 = (n3) => {
+var formatNumber5 = (n3) => {
   return n3.toExponential(6);
 };
 function formatRows(rows) {
@@ -270727,7 +272120,7 @@ var resultToTable = (result) => {
     for (let i2 = 0;i2 < result.numPoints; i2++) {
       const row = [
         i2.toString(),
-        ...uniqueData.map((d3) => formatNumber3(d3.values[i2]))
+        ...uniqueData.map((d3) => formatNumber5(d3.values[i2]))
       ];
       dataRows2.push(row);
     }
@@ -270742,8 +272135,8 @@ var resultToTable = (result) => {
     const row = [
       i2.toString(),
       ...uniqueData.flatMap((d3) => [
-        formatNumber3(d3.values[i2].real),
-        formatNumber3(d3.values[i2].img)
+        formatNumber5(d3.values[i2].real),
+        formatNumber5(d3.values[i2].img)
       ])
     ];
     dataRows.push(row);
@@ -274159,6 +275552,7 @@ registerCheckPinSpecification(program2);
 registerCheckPlacement(program2);
 registerCheckRoutingDifficulty(program2);
 registerCheckRouting(program2);
+registerCheckTraceLength(program2);
 registerRegistry(program2);
 registerRegistryPackages(program2);
 registerRegistryPackagesCreate(program2);