@tscircuit/cli 0.1.2278 → 0.1.2279

package/dist/cli/main.js

@@ -57778,6 +57778,613 @@ var init_dist = __esm(() => {
     MAT4: 16
   };
 });
+// node_modules/@tscircuit/circuit-json-pcb-style-analysis/lib/segments.ts
+function endpoint(p, outgoing) {
+  if (p.route_type === "through_pad")
+    return outgoing ? p.end : p.start;
+  return { x: p.x, y: p.y };
+}
+function layer(p, outgoing) {
+  if (p.route_type === "wire")
+    return p.layer;
+  if (p.route_type === "via")
+    return outgoing ? p.to_layer : p.from_layer;
+  return outgoing ? p.end_layer : p.start_layer;
+}
+function buildAnalysisContext(circuitJson) {
+  const segments = [];
+  for (const [circuitJsonIndex, item] of circuitJson.entries()) {
+    if (item.type !== "pcb_trace")
+      continue;
+    for (let i = 0;i < item.route.length - 1; i++) {
+      const a = item.route[i];
+      const b = item.route[i + 1];
+      const supported = (p) => ["wire", "via", "through_pad"].includes(p.route_type);
+      if (!supported(a) || !supported(b))
+        throw new Error(item.pcb_trace_id + ": unsupported route point at " + i);
+      if (a.route_type !== "wire" && b.route_type !== "wire")
+        continue;
+      if (layer(a, true) !== layer(b, false))
+        continue;
+      const start = endpoint(a, true);
+      const end = endpoint(b, false);
+      if (![start.x, start.y, end.x, end.y].every(Number.isFinite))
+        throw new Error(item.pcb_trace_id + ": nonfinite route coordinates at " + i);
+      const lengthMm = Math.hypot(end.x - start.x, end.y - start.y);
+      if (lengthMm <= 0.000000001)
+        continue;
+      const wire = a.route_type === "wire" ? a : b;
+      const width = wire.route_type === "wire" ? Math.max(wire.width, wire.end_width ?? wire.width) : 0;
+      if (!Number.isFinite(width) || width <= 0)
+        throw new Error(item.pcb_trace_id + ": invalid wire width at " + i);
+      segments.push({
+        pcbTraceId: item.pcb_trace_id,
+        sourceTraceId: item.source_trace_id,
+        pcbGroupId: item.pcb_group_id,
+        subcircuitId: item.subcircuit_id,
+        circuitJsonIndex,
+        startRouteIndex: i,
+        endRouteIndex: i + 1,
+        layer: layer(a, true),
+        start: { ...start },
+        end: { ...end },
+        width,
+        lengthMm
+      });
+    }
+  }
+  return { circuitJson, segments };
+}
+
+// node_modules/@tscircuit/circuit-json-pcb-style-analysis/lib/issue-highlights.ts
+function getIssueHighlights(issues) {
+  return issues.map((issue) => ({
+    issue,
+    color: "#ff5555",
+    message: issue.message
+  }));
+}
+
+// node_modules/@tscircuit/circuit-json-pcb-style-analysis/lib/visualize.ts
+function visualizeIssues(ctx, issues) {
+  const highlights = getIssueHighlights(issues);
+  return {
+    coordinateSystem: "cartesian",
+    lines: [
+      ...ctx.segments.map((s) => ({
+        points: [s.start, s.end],
+        strokeColor: s.layer === "bottom" ? "#60a5fa" : "#94a3b8",
+        strokeWidth: s.width
+      })),
+      ...highlights.flatMap(({ issue, color, message }) => (issue.constituentSegments ?? [issue]).map((segment) => ({
+        points: [segment.start, segment.end],
+        strokeColor: color,
+        strokeWidth: Math.max(segment.width * 2, 0.25),
+        label: message
+      })))
+    ],
+    points: highlights.map(({ issue, color, message }, i) => ({
+      ...issue.location,
+      color,
+      label: i + 1 + ": " + message
+    }))
+  };
+}
+var init_visualize = () => {};
+
+// node_modules/@tscircuit/circuit-json-pcb-style-analysis/lib/trace-runs.ts
+function distanceToSegment(p, a, b) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const lengthSquared = dx * dx + dy * dy;
+  const t = lengthSquared ? Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / lengthSquared)) : 0;
+  return Math.hypot(p.x - a.x - t * dx, p.y - a.y - t * dy);
+}
+function buildTraceRuns(ctx) {
+  const runs = [];
+  const simplify = (segments) => {
+    const pending = [[0, segments.length - 1]];
+    while (pending.length) {
+      const [lo, hi] = pending.pop();
+      if (lo === hi)
+        continue;
+      const start = segments[lo].start;
+      const end = segments[hi].end;
+      let width = Infinity;
+      let maxDistance = -1;
+      let split = lo;
+      for (let i = lo;i <= hi; i++) {
+        width = Math.min(width, segments[i].width);
+        if (i === hi)
+          continue;
+        const distance = distanceToSegment(segments[i].end, start, end);
+        if (distance > maxDistance) {
+          maxDistance = distance;
+          split = i;
+        }
+      }
+      if (maxDistance > width / 2 + 0.000000001) {
+        pending.push([split + 1, hi], [lo, split]);
+        continue;
+      }
+      const constituentSegments = segments.slice(lo, hi + 1);
+      runs.push({
+        ...segments[lo],
+        endRouteIndex: segments[hi].endRouteIndex,
+        end,
+        width: constituentSegments.reduce((max, s) => Math.max(max, s.width), 0),
+        lengthMm: Math.hypot(end.x - start.x, end.y - start.y),
+        constituentSegments,
+        maxCenterlineDeviationMm: maxDistance <= 0.000000001 ? 0 : maxDistance
+      });
+    }
+  };
+  for (const connected of getConnectedTraceSegments(ctx))
+    simplify(connected);
+  return [...ctx.segments, ...runs];
+}
+function getConnectedTraceSegments(ctx) {
+  const chains = [];
+  let connected = [];
+  for (const segment of ctx.segments) {
+    const previous = connected.at(-1);
+    if (previous) {
+      const trace = ctx.circuitJson[segment.circuitJsonIndex];
+      const sameTrace = previous.circuitJsonIndex === segment.circuitJsonIndex;
+      const wireJoin = sameTrace && trace.type === "pcb_trace" && trace.route.slice(previous.endRouteIndex, segment.startRouteIndex + 1).every((p) => p.route_type === "wire" && p.layer === segment.layer);
+      if (!wireJoin || previous.layer !== segment.layer || Math.hypot(previous.end.x - segment.start.x, previous.end.y - segment.start.y) > 0.000000001) {
+        chains.push(connected);
+        connected = [];
+      }
+    }
+    connected.push(segment);
+  }
+  if (connected.length)
+    chains.push(connected);
+  return chains;
+}
+
+// node_modules/@tscircuit/circuit-json-pcb-style-analysis/lib/solvers/LongTraceSegmentSolver.ts
+import { BaseSolver } from "@tscircuit/solver-utils";
+var LongTraceSegmentSolver;
+var init_LongTraceSegmentSolver = __esm(() => {
+  init_visualize();
+  LongTraceSegmentSolver = class LongTraceSegmentSolver extends BaseSolver {
+    params;
+    segments = [];
+    nextSegment = 0;
+    candidates;
+    constructor(params2) {
+      super();
+      this.params = params2;
+      if (!Number.isFinite(params2.maxSegmentLengthMm) || params2.maxSegmentLengthMm <= 0)
+        throw new Error("maxSegmentLengthMm must be finite and positive");
+      this.candidates = buildTraceRuns(params2.ctx);
+      this.MAX_ITERATIONS = this.candidates.length + 2;
+    }
+    _step() {
+      const segment = this.candidates[this.nextSegment++];
+      if (!segment) {
+        this.solved = true;
+        this.progress = 1;
+        return;
+      }
+      if (segment.lengthMm > this.params.maxSegmentLengthMm)
+        this.segments.push(segment);
+      this.progress = this.nextSegment / this.candidates.length;
+      this.stats = {
+        segmentsChecked: this.nextSegment,
+        candidateCount: this.segments.length
+      };
+    }
+    getOutput() {
+      return this.segments;
+    }
+    visualize() {
+      return visualizeIssues(this.params.ctx, []);
+    }
+    getConstructorParams() {
+      return [this.params];
+    }
+  };
+});
+
+// node_modules/@tscircuit/circuit-json-pcb-style-analysis/lib/solvers/SegmentIssueSolver.ts
+import { BaseSolver as BaseSolver2 } from "@tscircuit/solver-utils";
+function locateIssue(segment, rule) {
+  const { start, end } = segment;
+  const parts = segment.constituentSegments ?? [segment];
+  const bounds = parts.reduce((bounds, s) => ({
+    minX: Math.min(bounds.minX, s.start.x - s.width / 2, s.end.x - s.width / 2),
+    minY: Math.min(bounds.minY, s.start.y - s.width / 2, s.end.y - s.width / 2),
+    maxX: Math.max(bounds.maxX, s.start.x + s.width / 2, s.end.x + s.width / 2),
+    maxY: Math.max(bounds.maxY, s.start.y + s.width / 2, s.end.y + s.width / 2)
+  }), { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity });
+  return {
+    ...segment,
+    issueId: rule + ":" + segment.circuitJsonIndex + ":" + segment.startRouteIndex,
+    severity: "error",
+    message: "",
+    location: { x: (start.x + end.x) / 2, y: (start.y + end.y) / 2 },
+    bounds
+  };
+}
+var SegmentIssueSolver;
+var init_SegmentIssueSolver = __esm(() => {
+  init_visualize();
+  SegmentIssueSolver = class SegmentIssueSolver extends BaseSolver2 {
+    ctx;
+    issues = [];
+    nextSegment = 0;
+    constructor(ctx) {
+      super();
+      this.ctx = ctx;
+      this.MAX_ITERATIONS = ctx.segments.length + 2;
+    }
+    _step() {
+      const segment = this.ctx.segments[this.nextSegment++];
+      if (!segment) {
+        this.solved = true;
+        this.progress = 1;
+        return;
+      }
+      const issue = this.checkSegment(segment);
+      if (issue)
+        this.issues.push(issue);
+      this.progress = this.nextSegment / this.ctx.segments.length;
+      this.stats = {
+        segmentsChecked: this.nextSegment,
+        issueCount: this.issues.length
+      };
+    }
+    getOutput() {
+      return this.issues;
+    }
+    visualize() {
+      return visualizeIssues(this.ctx, this.issues);
+    }
+  };
+});
+
+// node_modules/@tscircuit/circuit-json-pcb-style-analysis/lib/solvers/OddAngleTraceSegmentSolver.ts
+var OddAngleTraceSegmentSolver;
+var init_OddAngleTraceSegmentSolver = __esm(() => {
+  init_visualize();
+  init_SegmentIssueSolver();
+  OddAngleTraceSegmentSolver = class OddAngleTraceSegmentSolver extends SegmentIssueSolver {
+    params;
+    constructor(params2) {
+      super({
+        ...params2.ctx,
+        segments: params2.candidateSegments ?? buildTraceRuns(params2.ctx)
+      });
+      this.params = params2;
+      if (!Number.isFinite(params2.maxSegmentLengthMm) || params2.maxSegmentLengthMm <= 0)
+        throw new Error("maxSegmentLengthMm must be finite and positive");
+      if (!Number.isFinite(params2.angleToleranceDegrees) || params2.angleToleranceDegrees < 0 || params2.angleToleranceDegrees >= 22.5)
+        throw new Error("angleToleranceDegrees must be in [0, 22.5)");
+      const covered = new Set;
+      for (const segment of this.ctx.segments) {
+        if (!segment.constituentSegments || !this.checkSegment(segment))
+          continue;
+        for (const part of segment.constituentSegments)
+          covered.add(part.circuitJsonIndex + ":" + part.startRouteIndex);
+      }
+      this.ctx = {
+        ...this.ctx,
+        segments: this.ctx.segments.filter((s) => s.constituentSegments || !covered.has(s.circuitJsonIndex + ":" + s.startRouteIndex))
+      };
+    }
+    checkSegment(s) {
+      if (s.lengthMm <= this.params.maxSegmentLengthMm)
+        return;
+      const angleDegrees = (Math.atan2(s.end.y - s.start.y, s.end.x - s.start.x) * 180 / Math.PI + 360) % 360;
+      const nearest = Math.round(angleDegrees / 45) * 45;
+      const deviationDegrees = Math.abs(angleDegrees - nearest);
+      const uncertaintyDegrees = Math.atan2(2 * (s.maxCenterlineDeviationMm ?? 0), s.lengthMm) * 180 / Math.PI;
+      if (deviationDegrees <= this.params.angleToleranceDegrees + uncertaintyDegrees + 0.0000000001)
+        return;
+      return {
+        ...locateIssue(s, "odd-angle"),
+        lineItemType: "PcbTraceSegmentOddAngle",
+        maxSegmentLengthMm: this.params.maxSegmentLengthMm,
+        angleDegrees,
+        nearestAllowedAngleDegrees: nearest % 360,
+        deviationDegrees,
+        angleToleranceDegrees: this.params.angleToleranceDegrees,
+        ...s.constituentSegments ? { angleUncertaintyDegrees: uncertaintyDegrees } : {},
+        message: s.pcbTraceId + (s.constituentSegments ? " run " + s.startRouteIndex + " → " + s.endRouteIndex : " segment " + s.startRouteIndex) + " on " + s.layer + " is " + s.lengthMm.toFixed(3) + " mm long (threshold " + this.params.maxSegmentLengthMm + " mm) and at " + angleDegrees.toFixed(3) + "°; nearest allowed direction " + nearest % 360 + "° (deviation " + deviationDegrees.toFixed(3) + "°, tolerance " + this.params.angleToleranceDegrees + "°" + (uncertaintyDegrees ? ", approximation allowance " + uncertaintyDegrees.toFixed(3) + "°" : "") + ")"
+      };
+    }
+    visualize() {
+      return visualizeIssues(this.params.ctx, this.issues);
+    }
+    getConstructorParams() {
+      return [this.params];
+    }
+  };
+});
+
+// node_modules/@tscircuit/circuit-json-pcb-style-analysis/lib/solvers/StaircaseTraceSolver.ts
+function direction(s) {
+  const angle = (Math.atan2(s.end.y - s.start.y, s.end.x - s.start.x) * 180 / Math.PI + 360) % 360;
+  return angle;
+}
+function angleDistance(a, b) {
+  return Math.abs((a - b + 540) % 360 - 180);
+}
+var StaircaseTraceSolver;
+var init_StaircaseTraceSolver = __esm(() => {
+  init_visualize();
+  init_SegmentIssueSolver();
+  StaircaseTraceSolver = class StaircaseTraceSolver extends SegmentIssueSolver {
+    params;
+    bendCounts = new Map;
+    constructor(params2) {
+      super({ ...params2.ctx, segments: [] });
+      this.params = params2;
+      const minBends = params2.minStaircaseBends ?? 6;
+      const minLength = params2.minStaircaseLengthMm ?? 2;
+      const maxStep = params2.maxStairStepLengthMm ?? 1;
+      if (!Number.isInteger(minBends) || minBends < 2)
+        throw new Error("minStaircaseBends must be an integer of at least 2");
+      if (!Number.isFinite(minLength) || minLength <= 0)
+        throw new Error("minStaircaseLengthMm must be finite and positive");
+      if (!Number.isFinite(maxStep) || maxStep <= 0)
+        throw new Error("maxStairStepLengthMm must be finite and positive");
+      const candidates = [];
+      for (const chain of getConnectedTraceSegments(params2.ctx)) {
+        const steps = [];
+        for (const s of chain) {
+          const heading = direction(s);
+          const last = steps.at(-1);
+          if (last && angleDistance(last.direction, heading) <= 4 + 0.0000000001) {
+            last.parts.push(s);
+            last.lengthMm += s.lengthMm;
+          } else
+            steps.push({ direction: heading, parts: [s], lengthMm: s.lengthMm });
+        }
+        for (let i = 0;i < steps.length - 1; ) {
+          const a = steps[i], b = steps[i + 1];
+          const difference = angleDistance(a.direction, b.direction);
+          if (difference < 15 - 0.0000000001 || difference > 90 + 0.0000000001 || a.lengthMm > maxStep + 0.000000001 || b.lengthMm > maxStep + 0.000000001) {
+            i++;
+            continue;
+          }
+          let end = i + 2;
+          while (end < steps.length && angleDistance(steps[end].direction, steps[i + (end - i) % 2].direction) <= 4 + 0.0000000001 && steps[end].lengthMm <= maxStep + 0.000000001)
+            end++;
+          const parts = steps.slice(i, end).flatMap((s) => s.parts);
+          const lengthMm = parts.reduce((n, s) => n + s.lengthMm, 0);
+          if (end - i - 1 >= minBends && lengthMm + 0.000000001 >= minLength) {
+            const candidate = {
+              ...parts[0],
+              end: parts.at(-1).end,
+              endRouteIndex: parts.at(-1).endRouteIndex,
+              width: parts.reduce((width, s) => Math.max(width, s.width), 0),
+              lengthMm,
+              constituentSegments: parts
+            };
+            candidates.push(candidate);
+            this.bendCounts.set(candidate, end - i - 1);
+            i = end;
+          } else
+            i = end - 1;
+        }
+      }
+      this.ctx = { ...params2.ctx, segments: candidates };
+      this.MAX_ITERATIONS = candidates.length + 2;
+    }
+    checkSegment(s) {
+      const bendCount = this.bendCounts.get(s);
+      return {
+        ...locateIssue(s, "staircase"),
+        lineItemType: "PcbTraceStaircase",
+        bendCount,
+        minStaircaseBends: this.params.minStaircaseBends ?? 6,
+        minStaircaseLengthMm: this.params.minStaircaseLengthMm ?? 2,
+        maxStairStepLengthMm: this.params.maxStairStepLengthMm ?? 1,
+        message: `${s.pcbTraceId} route ${s.startRouteIndex} → ${s.endRouteIndex} on ${s.layer} has ${bendCount} alternating staircase bends over ${s.lengthMm.toFixed(3)} mm`
+      };
+    }
+    visualize() {
+      return visualizeIssues(this.params.ctx, this.issues);
+    }
+    getConstructorParams() {
+      return [this.params];
+    }
+  };
+});
+
+// node_modules/@tscircuit/circuit-json-pcb-style-analysis/lib/solvers/PcbStyleAnalysisPipeline.ts
+import {
+  BasePipelineSolver,
+  definePipelineStep
+} from "@tscircuit/solver-utils";
+var PcbStyleAnalysisPipeline;
+var init_PcbStyleAnalysisPipeline = __esm(() => {
+  init_visualize();
+  init_LongTraceSegmentSolver();
+  init_OddAngleTraceSegmentSolver();
+  init_StaircaseTraceSolver();
+  PcbStyleAnalysisPipeline = class PcbStyleAnalysisPipeline extends BasePipelineSolver {
+    options;
+    ctx;
+    pipelineDef = [
+      definePipelineStep("LongTraceSegmentSolver", LongTraceSegmentSolver, (p) => [
+        { ctx: p.ctx, maxSegmentLengthMm: p.options.maxSegmentLengthMm ?? 5 }
+      ]),
+      definePipelineStep("OddAngleTraceSegmentSolver", OddAngleTraceSegmentSolver, (p) => [
+        {
+          ctx: p.ctx,
+          candidateSegments: p.getSolver("LongTraceSegmentSolver").getOutput(),
+          maxSegmentLengthMm: p.options.maxSegmentLengthMm ?? 5,
+          angleToleranceDegrees: p.options.angleToleranceDegrees ?? 4
+        }
+      ]),
+      definePipelineStep("StaircaseTraceSolver", StaircaseTraceSolver, (p) => [
+        {
+          ctx: p.ctx,
+          minStaircaseBends: p.options.minStaircaseBends,
+          minStaircaseLengthMm: p.options.minStaircaseLengthMm,
+          maxStairStepLengthMm: p.options.maxStairStepLengthMm
+        }
+      ])
+    ];
+    constructor(circuitJson, options = {}) {
+      super(circuitJson);
+      this.options = options;
+      if (options.issueTypes) {
+        const oddAngles = options.issueTypes.includes("PcbTraceSegmentOddAngle");
+        const staircases = options.issueTypes.includes("PcbTraceStaircase");
+        this.pipelineDef = this.pipelineDef.filter((step) => step.solverName === "StaircaseTraceSolver" ? staircases : oddAngles);
+      }
+      this.MAX_ITERATIONS = circuitJson.reduce((n, e) => n + (e.type === "pcb_trace" ? e.route.length * 5 : 0), 10);
+    }
+    _setup() {
+      this.ctx = buildAnalysisContext(this.inputProblem);
+    }
+    getOutput() {
+      return {
+        issues: [
+          ...this.getSolver("OddAngleTraceSegmentSolver")?.getOutput() ?? [],
+          ...this.getSolver("StaircaseTraceSolver")?.getOutput() ?? []
+        ]
+      };
+    }
+    getConstructorParams() {
+      return [this.inputProblem, this.options];
+    }
+    initialVisualize() {
+      this.setup();
+      return visualizeIssues(this.ctx, []);
+    }
+    finalVisualize() {
+      this.setup();
+      return visualizeIssues(this.ctx, this.getOutput().issues);
+    }
+  };
+});
+
+// node_modules/@tscircuit/circuit-json-pcb-style-analysis/lib/analyze-pcb-style.ts
+function analyzePcbStyle(circuitJson, options = {}) {
+  const solver = new PcbStyleAnalysisPipeline(circuitJson, options);
+  solver.solve();
+  if (solver.failed)
+    throw new Error(solver.error ?? "PCB style analysis failed");
+  return solver.getOutput();
+}
+var init_analyze_pcb_style = __esm(() => {
+  init_PcbStyleAnalysisPipeline();
+});
+
+// node_modules/@tscircuit/circuit-json-pcb-style-analysis/lib/create-pcb-style-issue-artifacts.ts
+function escapeXml(value) {
+  return value.replace(/[&<>"']/g, (c) => ({
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&apos;"
+  })[c]);
+}
+function describeIssueXml(issue) {
+  return "<" + issue.lineItemType + ' severity="error" pcbTraceId="' + escapeXml(issue.pcbTraceId) + '" startRouteIndex="' + issue.startRouteIndex + '" endRouteIndex="' + issue.endRouteIndex + '" layer="' + escapeXml(issue.layer) + '" x="' + issue.location.x + '" y="' + issue.location.y + '" lengthMm="' + issue.lengthMm + '" message="' + escapeXml(issue.message) + '" />';
+}
+function renderPcbStyleSvg(circuitJson, issues, options = {}) {
+  const ctx = buildAnalysisContext(circuitJson);
+  const segments = ctx.segments.filter((s) => !options.layer || s.layer === options.layer);
+  const points = segments.flatMap((s) => [s.start, s.end]);
+  const bounds = options.bounds ?? {
+    minX: Math.min(0, ...points.map((p) => p.x)) - 2,
+    minY: Math.min(0, ...points.map((p) => p.y)) - 2,
+    maxX: Math.max(0, ...points.map((p) => p.x)) + 2,
+    maxY: Math.max(0, ...points.map((p) => p.y)) + 2
+  };
+  const scale = Math.min(740 / Math.max(1, bounds.maxX - bounds.minX), 350 / Math.max(1, bounds.maxY - bounds.minY));
+  const cx = (bounds.minX + bounds.maxX) / 2;
+  const cy = (bounds.minY + bounds.maxY) / 2;
+  const x = (n) => Number((400 + (n - cx) * scale).toFixed(4));
+  const y = (n) => Number((215 - (n - cy) * scale).toFixed(4));
+  const line = (s, color, highlight = false) => '<line x1="' + x(s.start.x) + '" y1="' + y(s.start.y) + '" x2="' + x(s.end.x) + '" y2="' + y(s.end.y) + '" stroke="' + color + '" stroke-width="' + Number(Math.max(highlight ? 4 : 1, s.width * scale * (highlight ? 1.8 : 1)).toFixed(4)) + '" stroke-linecap="round"/>';
+  const context = segments.filter((s) => Math.max(s.start.x, s.end.x) + s.width >= bounds.minX && Math.min(s.start.x, s.end.x) - s.width <= bounds.maxX && Math.max(s.start.y, s.end.y) + s.width >= bounds.minY && Math.min(s.start.y, s.end.y) - s.width <= bounds.maxY).map((s) => line(s, s.layer === "bottom" ? "#74a9d8" : "#9aa9a2")).join("");
+  const individual = options.bounds !== undefined && issues.length === 1;
+  const highlights = getIssueHighlights(issues).map(({ issue: s, color }, i) => (s.constituentSegments ?? [s]).map((part) => line(part, color, true)).join("") + (individual ? '<circle cx="' + x(s.location.x) + '" cy="' + y(s.location.y) + '" r="10" fill="#fff" stroke="' + color + '" stroke-width="2"/>' + '<text x="' + x(s.location.x) + '" y="' + (y(s.location.y) + 4) + '" text-anchor="middle" fill="#9b1111" font-size="11">' + (i + 1) + "</text>" : "")).join("");
+  const title = options.title ?? "PCB style analysis — " + issues.length + " errors";
+  const details = individual ? [
+    issues[0].message,
+    "Start (" + issues[0].start.x.toFixed(3) + ", " + issues[0].start.y.toFixed(3) + ") → End (" + issues[0].end.x.toFixed(3) + ", " + issues[0].end.y.toFixed(3) + ") mm",
+    "Layer: " + issues[0].layer + " | Circuit JSON index: " + issues[0].circuitJsonIndex + " | Route indices: " + issues[0].startRouteIndex + " → " + issues[0].endRouteIndex
+  ] : [
+    "Red: PCB traces with detected style issues",
+    "Coordinates in millimeters; Y points upward. " + issues.length + " located errors."
+  ];
+  return '<svg xmlns="http://www.w3.org/2000/svg" width="800" height="490" viewBox="0 0 800 490"><title>' + escapeXml(title) + '</title><rect width="800" height="490" fill="#10271c"/><style>text{font-family:monospace}</style><text x="20" y="26" fill="#fff" font-size="16">' + escapeXml(title) + '</text><defs><clipPath id="board"><rect x="15" y="40" width="770" height="350"/></clipPath></defs><g clip-path="url(#board)">' + context + highlights + '</g><rect x="0" y="400" width="800" height="90" fill="#f1f5f9"/>' + details.map((t, i) => '<text x="16" y="' + (423 + i * 22) + '" fill="#152d22" font-size="11">' + escapeXml(t) + "</text>").join("") + `</svg>
+`;
+}
+function createPcbStyleIssueArtifacts(circuitJson, options = {}) {
+  const analysis = options.analysis ?? analyzePcbStyle(circuitJson, {
+    maxSegmentLengthMm: options.maxSegmentLengthMm,
+    angleToleranceDegrees: options.angleToleranceDegrees,
+    minStaircaseBends: options.minStaircaseBends,
+    minStaircaseLengthMm: options.minStaircaseLengthMm,
+    maxStairStepLengthMm: options.maxStairStepLengthMm
+  });
+  return analysis.issues.flatMap((issue, issueIndex) => {
+    if (options.layer && issue.layer !== options.layer)
+      return [];
+    if (options.issueTypes && !options.issueTypes.includes(issue.lineItemType))
+      return [];
+    const margin = Math.max(2, (issue.bounds.maxX - issue.bounds.minX) * 0.2, (issue.bounds.maxY - issue.bounds.minY) * 0.2);
+    const crop = {
+      minX: issue.bounds.minX - margin,
+      minY: issue.bounds.minY - margin,
+      maxX: issue.bounds.maxX + margin,
+      maxY: issue.bounds.maxY + margin
+    };
+    return [
+      {
+        issueIndex,
+        issue,
+        layer: issue.layer,
+        bounds: issue.bounds,
+        descriptionXml: describeIssueXml(issue),
+        fileName: "issue-" + String(issueIndex + 1).padStart(4, "0") + "-" + issue.lineItemType + ".svg",
+        contentType: "image/svg+xml",
+        content: renderPcbStyleSvg(circuitJson, [issue], {
+          bounds: crop,
+          layer: issue.layer,
+          title: "Issue " + (issueIndex + 1) + " — " + issue.lineItemType
+        })
+      }
+    ];
+  });
+}
+var init_create_pcb_style_issue_artifacts = __esm(() => {
+  init_analyze_pcb_style();
+});
+
+// node_modules/@tscircuit/circuit-json-pcb-style-analysis/lib/index.ts
+var exports_lib = {};
+__export3(exports_lib, {
+  LongTraceSegmentSolver: () => LongTraceSegmentSolver,
+  OddAngleTraceSegmentSolver: () => OddAngleTraceSegmentSolver,
+  PcbStyleAnalysisPipeline: () => PcbStyleAnalysisPipeline,
+  StaircaseTraceSolver: () => StaircaseTraceSolver,
+  analyzePcbStyle: () => analyzePcbStyle,
+  createPcbStyleIssueArtifacts: () => createPcbStyleIssueArtifacts,
+  describeIssueXml: () => describeIssueXml,
+  escapeXml: () => escapeXml,
+  renderPcbStyleSvg: () => renderPcbStyleSvg
+});
+var init_lib2 = __esm(() => {
+  init_analyze_pcb_style();
+  init_create_pcb_style_issue_artifacts();
+  init_PcbStyleAnalysisPipeline();
+  init_LongTraceSegmentSolver();
+  init_OddAngleTraceSegmentSolver();
+  init_StaircaseTraceSolver();
+});
 
 // node_modules/@tscircuit/circuit-json-routing-analysis/dist/chunk-4ISXDEM5.js
 import * as Soup from "circuit-json";
@@ -99200,7 +99807,7 @@ var import_gerber_to_svg, renderTscircuitRepro = async (tsx, options = {}) => {
     x: rect.x + (point.x - bounds.minX) / (bounds.maxX - bounds.minX) * rect.width,
     y: rect.y + (bounds.maxY - point.y) / (bounds.maxY - bounds.minY) * rect.height
   };
-}, escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;"), shortMarkerStroke = "#9b5cff", createShortDebugSvg = (circuitJson, shorts, options = {}) => {
+}, escapeXml2 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;"), shortMarkerStroke = "#9b5cff", createShortDebugSvg = (circuitJson, shorts, options = {}) => {
   const shortLayers = new Set(shorts.map((short) => short.layer));
   const layer = options.layer ?? (shortLayers.size === 1 ? [...shortLayers][0] : undefined);
   const baseSvg = convertCircuitJsonToPcbSvg22(circuitJson, { layer });
@@ -99217,8 +99824,8 @@ var import_gerber_to_svg, renderTscircuitRepro = async (tsx, options = {}) => {
     const secondLabel = short.secondOwnerLabels.join(", ");
     const text = `SHORT ${index + 1}: ${firstLabel} <-> ${secondLabel}`;
     return `
-  <g data-type="short-debug" data-mode="${escapeXml(short.mode)}" data-layer="${escapeXml(short.layer)}">
-    <title>${escapeXml(text)}</title>
+  <g data-type="short-debug" data-mode="${escapeXml2(short.mode)}" data-layer="${escapeXml2(short.layer)}">
+    <title>${escapeXml2(text)}</title>
     <circle cx="${point.x.toFixed(2)}" cy="${point.y.toFixed(2)}" r="14" fill="none" stroke="${shortMarkerStroke}" stroke-width="4"/>
     <circle cx="${point.x.toFixed(2)}" cy="${point.y.toFixed(2)}" r="6" fill="none" stroke="${shortMarkerStroke}" stroke-width="3"/>
   </g>`;
@@ -99427,9 +100034,9 @@ class Trace {
   }
   toString() {
     const lines = [
-      `<Trace id="${escapeXml2(this.id)}" label="${escapeXml2(this.label)}" connectionType="${escapeXml2(this.connectionType)}" lengthMm="${formatNumber3(this.lengthMm)}" straightLineDistanceMm="${formatNumber3(this.straightLineDistanceMm)}">`,
+      `<Trace id="${escapeXml3(this.id)}" label="${escapeXml3(this.label)}" connectionType="${escapeXml3(this.connectionType)}" lengthMm="${formatNumber3(this.lengthMm)}" straightLineDistanceMm="${formatNumber3(this.straightLineDistanceMm)}">`,
       `  <ConnectedPins>`,
-      ...this.connectedPins.map((pin) => `    <Pin ref="${escapeXml2(pin.ref)}" />`),
+      ...this.connectedPins.map((pin) => `    <Pin ref="${escapeXml3(pin.ref)}" />`),
       `  </ConnectedPins>`,
       `  <PinPositions>`,
       ...this.pinPositions.map((pin) => renderPinPosition(pin, "    ")),
@@ -99439,7 +100046,7 @@ class Trace {
       `</Trace>`
     ];
     if (this.points.length > 0) {
-      lines.splice(lines.length - 1, 0, `  <Path>`, ...this.points.map((point) => `    <Point x="${formatNumber3(point.x)}" y="${formatNumber3(point.y)}" layer="${escapeXml2(point.layer)}" kind="${escapeXml2(point.kind)}" />`), `  </Path>`);
+      lines.splice(lines.length - 1, 0, `  <Path>`, ...this.points.map((point) => `    <Point x="${formatNumber3(point.x)}" y="${formatNumber3(point.y)}" layer="${escapeXml3(point.layer)}" kind="${escapeXml3(point.kind)}" />`), `  </Path>`);
     }
     return lines.join(`
 `);
@@ -99468,7 +100075,7 @@ class TraceLengthAnalysis {
   }
   toString() {
     const lines = [
-      `<TraceLengthAnalysis requestedTarget="${escapeXml2(this.requestedTarget)}" resolvedTarget="${escapeXml2(this.resolvedTarget)}" targetKind="${escapeXml2(this.targetKind)}" traceCount="${this.traceCount}" totalLengthMm="${formatNumber3(this.totalLengthMm)}" totalStraightLineDistanceMm="${formatNumber3(this.totalStraightLineDistanceMm)}">`,
+      `<TraceLengthAnalysis requestedTarget="${escapeXml3(this.requestedTarget)}" resolvedTarget="${escapeXml3(this.resolvedTarget)}" targetKind="${escapeXml3(this.targetKind)}" traceCount="${this.traceCount}" totalLengthMm="${formatNumber3(this.totalLengthMm)}" totalStraightLineDistanceMm="${formatNumber3(this.totalStraightLineDistanceMm)}">`,
       ...this.#traces.flatMap((trace) => trace.toString().split(`
 `).map((line) => `  ${line}`)),
       `</TraceLengthAnalysis>`
@@ -99936,16 +100543,16 @@ function classifyPcbTracePoint(point, index, pointCount) {
 }
 function renderPinPosition(pin, indent) {
   if (typeof pin.x !== "number" || typeof pin.y !== "number") {
-    return `${indent}<Pin ref="${escapeXml2(pin.ref)}" position="unavailable" />`;
+    return `${indent}<Pin ref="${escapeXml3(pin.ref)}" position="unavailable" />`;
   }
   const layers = pin.layers.length > 0 ? pin.layers.join(",") : "unknown";
-  return `${indent}<Pin ref="${escapeXml2(pin.ref)}" x="${formatNumber3(pin.x)}" y="${formatNumber3(pin.y)}" layers="${escapeXml2(layers)}" />`;
+  return `${indent}<Pin ref="${escapeXml3(pin.ref)}" x="${formatNumber3(pin.x)}" y="${formatNumber3(pin.y)}" layers="${escapeXml3(layers)}" />`;
 }
 function renderConnection(trace) {
   if (trace.connectionTargetPosition) {
-    return `  <Connection kind="${escapeXml2(trace.connectionType)}" target="${escapeXml2(trace.connectionTarget)}" x="${formatNumber3(trace.connectionTargetPosition.x)}" y="${formatNumber3(trace.connectionTargetPosition.y)}" layer="${escapeXml2(trace.connectionTargetPosition.layer)}" />`;
+    return `  <Connection kind="${escapeXml3(trace.connectionType)}" target="${escapeXml3(trace.connectionTarget)}" x="${formatNumber3(trace.connectionTargetPosition.x)}" y="${formatNumber3(trace.connectionTargetPosition.y)}" layer="${escapeXml3(trace.connectionTargetPosition.layer)}" />`;
   }
-  return `  <Connection kind="${escapeXml2(trace.connectionType)}" target="${escapeXml2(trace.connectionTarget)}" />`;
+  return `  <Connection kind="${escapeXml3(trace.connectionType)}" target="${escapeXml3(trace.connectionTarget)}" />`;
 }
 function renderRequirements(requirements, indent) {
   if (typeof requirements.maxLengthMm === "number") {
@@ -99992,12 +100599,12 @@ function distanceBetween(left, right) {
 function formatNumber3(value) {
   return value.toFixed(2);
 }
-function escapeXml2(value) {
+function escapeXml3(value) {
   return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
 
 // node_modules/circuit-json-trace-length-analysis/lib/index.ts
-var init_lib2 = () => {};
+var init_lib3 = () => {};
 
 // node_modules/@edge-runtime/node-utils/dist/index.js
 var require_dist7 = __commonJS2(function(exports, module) {
@@ -169933,7 +170540,7 @@ var init_convert_circuit_json_to_altium_zip = __esm(() => {
 });
 
 // node_modules/circuit-json-to-altium/lib/index.ts
-var init_lib3 = __esm(() => {
+var init_lib4 = __esm(() => {
   init_circuit_json_to_altium_converter();
   init_convert_circuit_json_to_altium_zip();
 });
@@ -171749,7 +172356,7 @@ var import_perfect_cli = __toESM3(require_dist3(), 1);
 // lib/getVersion.ts
 import { createRequire as createRequire2 } from "node:module";
 // package.json
-var version = "0.1.2277";
+var version = "0.1.2278";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -171766,6 +172373,7 @@ var package_default = {
     "@babel/standalone": "^7.26.9",
     "@biomejs/biome": "^1.9.4",
     "@tscircuit/check-shorts": "https://jscdn.tscircuit.com/@tscircuit/check-shorts/0.0.26.tgz",
+    "@tscircuit/circuit-json-pcb-style-analysis": "https://jscdn.tscircuit.com/@tscircuit/circuit-json-pcb-style-analysis/0.0.5.tgz",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.15",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.8",
     "@tscircuit/circuit-json-schematic-placement-analysis": "https://jscdn.tscircuit.com/@tscircuit/circuit-json-schematic-placement-analysis/0.0.50.tgz",
@@ -191030,12 +191638,9 @@ var registerCheckNetlist = (program) => {
   });
 };
 
-// cli/check/pin-specification/register.ts
-import { runAllPinSpecificationChecks } from "@tscircuit/checks";
-
-// cli/check/shared.ts
-import fs44 from "node:fs";
-import path49 from "node:path";
+// cli/check/pcb-style/register.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile } from "node:fs/promises";
+import path50 from "node:path";
 
 // lib/shared/is-circuit-json-file.ts
 var isCircuitJsonFile = (filePath) => {
@@ -191044,6 +191649,8 @@ var isCircuitJsonFile = (filePath) => {
 };
 
 // cli/check/shared.ts
+import fs44 from "node:fs";
+import path49 from "node:path";
 var resolveCheckInputFilePath = async (file) => {
   if (file) {
     return path49.isAbsolute(file) ? file : path49.resolve(process.cwd(), file);
@@ -191077,7 +191684,80 @@ var getCircuitJsonForCheck = async ({
   return circuitJson;
 };
 
+// cli/check/pcb-style/register.ts
+var PCB_STYLE_CDN_URL = "https://jscdn.tscircuit.com/@tscircuit/circuit-json-pcb-style-analysis/latest/+esm";
+var importFromPackage = async () => await Promise.resolve().then(() => (init_lib2(), exports_lib));
+var loadPcbStyleAnalysis = async (options = {}) => {
+  const preferCdn = options.preferCdn ?? process.env.TSCI_TEST_MODE !== "true";
+  if (!preferCdn)
+    return importFromPackage();
+  try {
+    const analyzer = await (options.importFromCdn ?? ((url) => import(url)))(PCB_STYLE_CDN_URL);
+    if (typeof analyzer.analyzePcbStyle !== "function" || typeof analyzer.renderPcbStyleSvg !== "function") {
+      throw new Error("The jscdn module is missing PCB style analysis exports");
+    }
+    return analyzer;
+  } catch (cdnError) {
+    try {
+      return await importFromPackage();
+    } catch (packageError) {
+      throw new AggregateError([cdnError, packageError], "Failed to load PCB style analysis from jscdn or the installed CLI package");
+    }
+  }
+};
+var checkPcbStyle = async (file, options = {}) => {
+  const { analyzePcbStyle, renderPcbStyleSvg } = await loadPcbStyleAnalysis();
+  const filePath = await resolveCheckInputFilePath(file);
+  const svgPath = path50.resolve(options.svg ?? path50.join("checks", "check-pcb-style", "pcb.svg"));
+  if (!svgPath.endsWith(".svg") || svgPath === filePath) {
+    throw new Error("--svg must name an SVG output file different from the input");
+  }
+  const input = isCircuitJsonFile(filePath) ? JSON.parse(await readFile2(filePath, "utf8")) : await getCircuitJsonForCheck({
+    filePath,
+    platformConfig: { pcbDisabled: false, routingDisabled: false }
+  });
+  if (!Array.isArray(input) || input.some((item) => !item || typeof item !== "object" || typeof item.type !== "string" || item.type === "pcb_trace" && (!Array.isArray(item.route) || typeof item.pcb_trace_id !== "string"))) {
+    throw new Error("Expected a Circuit JSON array; pcb_trace elements need pcb_trace_id and route");
+  }
+  const circuitJson = input;
+  const analysis = analyzePcbStyle(circuitJson);
+  const count = analysis.issues.length;
+  const output = [
+    count === 0 ? `No PCB style issues detected in ${path50.basename(filePath)}` : `Detected ${count} PCB style issue${count === 1 ? "" : "s"} in ${path50.basename(filePath)}`,
+    ...analysis.issues.map((issue) => `${issue.lineItemType}: ${issue.message}
+  Trace ${issue.pcbTraceId}, layer ${issue.layer}, circuit JSON index ${issue.circuitJsonIndex}, route ${issue.startRouteIndex} -> ${issue.endRouteIndex}`)
+  ].join(`
+`);
+  return {
+    output,
+    analysis,
+    svg: renderPcbStyleSvg(circuitJson, analysis.issues),
+    svgPath
+  };
+};
+var registerCheckPcbStyle = (program) => {
+  program.commands.find((command) => command.name() === "check").command("pcb-style").description("Detect long odd-angle runs and unnecessary staircase routing").argument("[file]", "Path to the entry file or prebuilt circuit JSON").option("--json", "Print the analysis as JSON").option("--svg <file>", "Save a highlighted overview (default: checks/check-pcb-style/pcb.svg)").action(async (file, options = {}) => {
+    try {
+      const result = await checkPcbStyle(file, options);
+      await mkdir2(path50.dirname(result.svgPath), { recursive: true });
+      await writeFile(result.svgPath, result.svg);
+      console.log(options.json ? JSON.stringify(result.analysis, null, 2) : result.output);
+      const artifactMessage = `PCB style overview written to ${result.svgPath}`;
+      if (options.json)
+        console.error(artifactMessage);
+      else
+        console.log(artifactMessage);
+      if (result.analysis.issues.length > 0)
+        process.exitCode = 1;
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exitCode = 1;
+    }
+  });
+};
+
 // cli/check/pin-specification/register.ts
+import { runAllPinSpecificationChecks } from "@tscircuit/checks";
 var checkPinSpecification = async (file) => {
   const resolvedInputFilePath = await resolveCheckInputFilePath(file);
   const typedCircuitJson = await getCircuitJsonForCheck({
@@ -269419,7 +270099,7 @@ expectTypesMatch("extra props b");
 expectTypesMatch("missing props b");
 expectTypesMatch(true);
 expectTypesMatch("property a has mismatched types");
-var direction = external_exports.enum(["up", "down", "left", "right"]);
+var direction2 = external_exports.enum(["up", "down", "left", "right"]);
 var directionAlongEdge = external_exports.enum([
   "top-to-bottom",
   "left-to-right",
@@ -286976,7 +287656,7 @@ var portProps = commonLayoutProps.extend({
   layers: external_exports.array(external_exports.string()).optional(),
   schX: external_exports.number().optional(),
   schY: external_exports.number().optional(),
-  direction,
+  direction: direction2,
   connectsTo: external_exports.string().or(external_exports.array(external_exports.string())).optional(),
   kicadPinMetadata: kicadPinMetadata.optional(),
   hasInversionCircle: external_exports.boolean().optional()
@@ -297606,7 +298286,7 @@ function formatSiUnit2(value) {
   return `${formatted}${prefix.symbol}`;
 }
 var import_debug10 = __toESM4(require_src2(), 1);
-var BaseSolver = class {
+var BaseSolver4 = class {
   MAX_ITERATIONS = 1e5;
   solved = false;
   failed = false;
@@ -297687,7 +298367,7 @@ var BaseSolver = class {
     };
   }
 };
-var BasePipelineSolver = class extends BaseSolver {
+var BasePipelineSolver2 = class extends BaseSolver4 {
   startTimeOfPhase = {};
   endTimeOfPhase = {};
   timeSpentOnPhase = {};
@@ -298184,7 +298864,7 @@ var makeNumbersRounded = (obj) => {
   }
   return obj;
 };
-var BaseSolver2 = class {
+var BaseSolver22 = class {
   MAX_ITERATIONS = 1e5;
   solved = false;
   failed = false;
@@ -298274,7 +298954,7 @@ var BaseSolver2 = class {
     this.timeToSolve = endTime - startTime;
   }
 };
-var MultiOffsetIrlsSolver = class extends BaseSolver2 {
+var MultiOffsetIrlsSolver = class extends BaseSolver22 {
   offsetPadPoints;
   targetPointMap;
   currentPosition;
@@ -298490,7 +299170,7 @@ var MultiOffsetIrlsSolver = class extends BaseSolver2 {
     return this.optimalPosition ?? this.currentPosition;
   }
 };
-var TwoPhaseIrlsSolver = class extends BaseSolver2 {
+var TwoPhaseIrlsSolver = class extends BaseSolver22 {
   offsetPadPoints;
   targetPointMap;
   constraintFn;
@@ -298786,7 +299466,7 @@ function getOutwardNormal(outlineSegment, ccwFullOutline) {
   }
   return geometricOutward;
 }
-var LargestRectOutsideOutlineFromPointSolver = class extends BaseSolver {
+var LargestRectOutsideOutlineFromPointSolver = class extends BaseSolver4 {
   ccwFullOutline;
   origin;
   globalBounds;
@@ -299140,7 +299820,7 @@ function isPointInPolygon(point9, polygon2) {
   }
   return inside2;
 }
-var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
+var OutlineSegmentCandidatePointSolver = class extends BaseSolver4 {
   outlineSegment;
   viableOutlineSegment = null;
   ccwFullOutline;
@@ -299764,7 +300444,7 @@ function checkOverlapWithPackedComponents({
     hasOverlap: false
   };
 }
-var SingleComponentPackSolver = class extends BaseSolver {
+var SingleComponentPackSolver = class extends BaseSolver4 {
   componentToPack;
   packedComponents;
   packPlacementStrategy;
@@ -300309,7 +300989,7 @@ function getPolygonCentroid(points) {
   cy2 /= 6 * signedArea2;
   return { x: cx2, y: cy2 };
 }
-var PackSolver2 = class extends BaseSolver {
+var PackSolver2 = class extends BaseSolver4 {
   packInput;
   unpackedComponentQueue = [];
   packedComponents = [];
@@ -301228,7 +301908,7 @@ var generateBRep = (pourPolygons) => {
   }
   return brep_shapes;
 };
-var CopperPourPipelineSolver = class extends BasePipelineSolver {
+var CopperPourPipelineSolver = class extends BasePipelineSolver2 {
   constructor(input) {
     super(input);
     this.input = input;
@@ -304158,7 +304838,7 @@ var layoutSchematicGraphVariants = (variants, {
   };
 };
 var import_debug12 = __toESM4(require_src2(), 1);
-var BaseSolver3 = class {
+var BaseSolver32 = class {
   MAX_ITERATIONS = 1e5;
   solved = false;
   failed = false;
@@ -304431,7 +305111,7 @@ function doBasicInputProblemLayout(inputProblem) {
   cachedProblems.set(problemHash, outputLayout);
   return structuredClone(outputLayout);
 }
-var ChipPartitionsSolver = class extends BaseSolver3 {
+var ChipPartitionsSolver = class extends BaseSolver32 {
   inputProblem;
   partitions = [];
   decouplingCapGroups;
@@ -304604,7 +305284,7 @@ var getColorFromString = (string, alpha = 1) => {
   }
   return `hsl(${Math.abs(hash) % 360}, 70%, 50%, ${alpha})`;
 };
-var IdentifyDecouplingCapsSolver = class extends BaseSolver3 {
+var IdentifyDecouplingCapsSolver = class extends BaseSolver32 {
   inputProblem;
   queuedChips;
   outputDecouplingCapGroups = [];
@@ -304894,7 +305574,7 @@ var getPadsBoundingBox = (pads) => {
   return { minX, maxX, minY, maxY };
 };
 var PIN_SIZE = 0.1;
-var SingleInnerPartitionPackingSolver = class extends BaseSolver3 {
+var SingleInnerPartitionPackingSolver = class extends BaseSolver32 {
   partitionInputProblem;
   layout = null;
   pinIdToStronglyConnectedPins;
@@ -305002,7 +305682,7 @@ var SingleInnerPartitionPackingSolver = class extends BaseSolver3 {
     return [this.partitionInputProblem];
   }
 };
-var PackInnerPartitionsSolver = class extends BaseSolver3 {
+var PackInnerPartitionsSolver = class extends BaseSolver32 {
   partitions;
   packedPartitions = [];
   completedSolvers = [];
@@ -305065,7 +305745,7 @@ var PackInnerPartitionsSolver = class extends BaseSolver3 {
     return [this.partitions];
   }
 };
-var PartitionPackingSolver = class extends BaseSolver3 {
+var PartitionPackingSolver = class extends BaseSolver32 {
   packedPartitions;
   inputProblem;
   finalLayout = null;
@@ -305321,7 +306001,7 @@ var getPinIdToStronglyConnectedPinsObj = (inputProblem) => {
   }
   return pinIdToStronglyConnectedPins;
 };
-function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
+function definePipelineStep2(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
     solverName,
     solverClass,
@@ -305329,7 +306009,7 @@ function definePipelineStep(solverName, solverClass, getConstructorParams, opts
     onSolved: opts.onSolved
   };
 }
-var LayoutPipelineSolver = class extends BaseSolver3 {
+var LayoutPipelineSolver = class extends BaseSolver32 {
   identifyDecouplingCapsSolver;
   chipPartitionsSolver;
   packInnerPartitionsSolver;
@@ -305343,10 +306023,10 @@ var LayoutPipelineSolver = class extends BaseSolver3 {
   chipPartitions;
   packedPartitions;
   pipelineDef = [
-    definePipelineStep("identifyDecouplingCapsSolver", IdentifyDecouplingCapsSolver, () => [this.inputProblem], {
+    definePipelineStep2("identifyDecouplingCapsSolver", IdentifyDecouplingCapsSolver, () => [this.inputProblem], {
       onSolved: (_layoutSolver) => {}
     }),
-    definePipelineStep("chipPartitionsSolver", ChipPartitionsSolver, () => [
+    definePipelineStep2("chipPartitionsSolver", ChipPartitionsSolver, () => [
       {
         inputProblem: this.inputProblem,
         decouplingCapGroups: this.identifyDecouplingCapsSolver?.outputDecouplingCapGroups
@@ -305356,7 +306036,7 @@ var LayoutPipelineSolver = class extends BaseSolver3 {
         this.chipPartitions = this.chipPartitionsSolver.partitions;
       }
     }),
-    definePipelineStep("packInnerPartitionsSolver", PackInnerPartitionsSolver, () => [
+    definePipelineStep2("packInnerPartitionsSolver", PackInnerPartitionsSolver, () => [
       {
         partitions: this.chipPartitions,
         pinIdToStronglyConnectedPins: this.pinIdToStronglyConnectedPins
@@ -305366,7 +306046,7 @@ var LayoutPipelineSolver = class extends BaseSolver3 {
         this.packedPartitions = this.packInnerPartitionsSolver.packedPartitions;
       }
     }),
-    definePipelineStep("partitionPackingSolver", PartitionPackingSolver, () => [
+    definePipelineStep2("partitionPackingSolver", PartitionPackingSolver, () => [
       {
         packedPartitions: this.packedPartitions || [],
         inputProblem: this.inputProblem
@@ -305642,7 +306322,7 @@ var ConnectivityMap2 = class {
     return true;
   }
 };
-var BaseSolver4 = class {
+var BaseSolver42 = class {
   MAX_ITERATIONS = 1e5;
   solved = false;
   failed = false;
@@ -305995,7 +306675,7 @@ ${pin._facingDirection ?? getPinDirection2(pin, chip)}`,
   }
   return graphics;
 };
-var MspConnectionPairSolver = class extends BaseSolver4 {
+var MspConnectionPairSolver = class extends BaseSolver42 {
   inputProblem;
   mspConnectionPairs = [];
   dcConnMap;
@@ -306324,7 +307004,7 @@ var pathKey = (pts, decimals = 6) => {
   const key = pts.map((p2) => `${p2.x.toFixed(decimals)},${p2.y.toFixed(decimals)}`).join("|");
   return key;
 };
-var SchematicTraceSingleLineSolver2 = class extends BaseSolver4 {
+var SchematicTraceSingleLineSolver2 = class extends BaseSolver42 {
   pins;
   inputProblem;
   chipMap;
@@ -306488,7 +307168,7 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver4 {
     return g2;
   }
 };
-var SchematicTraceLinesSolver = class extends BaseSolver4 {
+var SchematicTraceLinesSolver = class extends BaseSolver42 {
   inputProblem;
   mspConnectionPairs;
   dcConnMap;
@@ -306618,7 +307298,7 @@ var applyJogToTerminalSegment = ({
     }
   }
 };
-var TraceOverlapIssueSolver = class extends BaseSolver4 {
+var TraceOverlapIssueSolver = class extends BaseSolver42 {
   overlappingTraceSegments;
   traceNetIslands;
   SHIFT_DISTANCE = 0.1;
@@ -306734,7 +307414,7 @@ var TraceOverlapIssueSolver = class extends BaseSolver4 {
     return graphics;
   }
 };
-var TraceOverlapShiftSolver = class extends BaseSolver4 {
+var TraceOverlapShiftSolver = class extends BaseSolver42 {
   inputProblem;
   inputTracePaths;
   globalConnMap;
@@ -307313,7 +307993,7 @@ function visualizeSingleNetLabelPlacementSolver(solver) {
   }
   return graphics;
 }
-var SingleNetLabelPlacementSolver = class extends BaseSolver4 {
+var SingleNetLabelPlacementSolver = class extends BaseSolver42 {
   inputProblem;
   inputTraceMap;
   overlappingSameNetTraceGroup;
@@ -307525,7 +308205,7 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver4 {
     return visualizeSingleNetLabelPlacementSolver(this);
   }
 };
-var NetLabelPlacementSolver = class extends BaseSolver4 {
+var NetLabelPlacementSolver = class extends BaseSolver42 {
   inputProblem;
   inputTraceMap;
   overlappingSameNetTraceGroups;
@@ -307739,7 +308419,7 @@ var NetLabelPlacementSolver = class extends BaseSolver4 {
     return graphics;
   }
 };
-var MergedNetLabelObstacleSolver = class extends BaseSolver4 {
+var MergedNetLabelObstacleSolver = class extends BaseSolver42 {
   input;
   output;
   inputProblem;
@@ -308117,7 +308797,7 @@ var generateRerouteCandidates = ({
   });
   return [...fourPointCandidates, ...snipReconnectCandidates];
 };
-var SingleOverlapSolver = class extends BaseSolver4 {
+var SingleOverlapSolver = class extends BaseSolver42 {
   queuedCandidatePaths;
   solvedTracePath = null;
   initialTrace;
@@ -308191,7 +308871,7 @@ var SingleOverlapSolver = class extends BaseSolver4 {
     return graphics;
   }
 };
-var OverlapAvoidanceStepSolver = class extends BaseSolver4 {
+var OverlapAvoidanceStepSolver = class extends BaseSolver42 {
   inputProblem;
   netLabelPlacements;
   mergedLabelNetIdMap;
@@ -308289,7 +308969,7 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver4 {
     return graphics;
   }
 };
-var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver4 {
+var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver42 {
   inputProblem;
   traces;
   netLabelPlacements;
@@ -308443,7 +309123,7 @@ var NEAREST_NEIGHBOR_COUNT = 3;
 var distance48 = (p1, p2) => {
   return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
 };
-var LongDistancePairSolver = class extends BaseSolver4 {
+var LongDistancePairSolver = class extends BaseSolver42 {
   constructor(params2) {
     super();
     this.params = params2;
@@ -309254,7 +309934,7 @@ var visualizeCollision = (collisionInfo) => {
   }
   return collisionGraphics;
 };
-var UntangleTraceSubsolver = class extends BaseSolver4 {
+var UntangleTraceSubsolver = class extends BaseSolver42 {
   input;
   lShapesToProcess = [];
   visualizationMode = "l_shapes";
@@ -309487,7 +310167,7 @@ var is4PointRectangle = (path) => {
   const isVHVC = p0.x === p1.x && p1.y === p2.y && p2.x === p3.x && p0.y === p3.y;
   return isHVHC || isVHVC;
 };
-var TraceCleanupSolver = class extends BaseSolver4 {
+var TraceCleanupSolver = class extends BaseSolver42 {
   input;
   outputTraces;
   traceIdQueue;
@@ -309608,7 +310288,7 @@ var TraceCleanupSolver = class extends BaseSolver4 {
     return graphics;
   }
 };
-function definePipelineStep2(solverName, solverClass, getConstructorParams, opts = {}) {
+function definePipelineStep22(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
     solverName,
     solverClass,
@@ -309617,7 +310297,7 @@ function definePipelineStep2(solverName, solverClass, getConstructorParams, opts
     shouldSkip: opts.shouldSkip
   };
 }
-var SchematicTracePipelineSolver = class extends BaseSolver4 {
+var SchematicTracePipelineSolver = class extends BaseSolver42 {
   mspConnectionPairSolver;
   schematicTraceLinesSolver;
   longDistancePairSolver;
@@ -309632,10 +310312,10 @@ var SchematicTracePipelineSolver = class extends BaseSolver4 {
   firstIterationOfPhase;
   inputProblem;
   pipelineDef = [
-    definePipelineStep2("mspConnectionPairSolver", MspConnectionPairSolver, () => [{ inputProblem: this.inputProblem }], {
+    definePipelineStep22("mspConnectionPairSolver", MspConnectionPairSolver, () => [{ inputProblem: this.inputProblem }], {
       onSolved: (mspSolver) => {}
     }),
-    definePipelineStep2("schematicTraceLinesSolver", SchematicTraceLinesSolver, () => [
+    definePipelineStep22("schematicTraceLinesSolver", SchematicTraceLinesSolver, () => [
       {
         mspConnectionPairs: this.mspConnectionPairSolver.mspConnectionPairs,
         dcConnMap: this.mspConnectionPairSolver.dcConnMap,
@@ -309644,7 +310324,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver4 {
         chipMap: this.mspConnectionPairSolver.chipMap
       }
     ]),
-    definePipelineStep2("longDistancePairSolver", LongDistancePairSolver, (instance) => [
+    definePipelineStep22("longDistancePairSolver", LongDistancePairSolver, (instance) => [
       {
         inputProblem: instance.inputProblem,
         primaryMspConnectionPairs: instance.mspConnectionPairSolver.mspConnectionPairs,
@@ -309653,7 +310333,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver4 {
     ], {
       onSolved: (schematicTraceLinesSolver) => {}
     }),
-    definePipelineStep2("traceOverlapShiftSolver", TraceOverlapShiftSolver, () => [
+    definePipelineStep22("traceOverlapShiftSolver", TraceOverlapShiftSolver, () => [
       {
         inputProblem: this.inputProblem,
         inputTracePaths: this.longDistancePairSolver?.getOutput().allTracesMerged,
@@ -309662,7 +310342,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver4 {
     ], {
       onSolved: (_solver) => {}
     }),
-    definePipelineStep2("netLabelPlacementSolver", NetLabelPlacementSolver, () => [
+    definePipelineStep22("netLabelPlacementSolver", NetLabelPlacementSolver, () => [
       {
         inputProblem: this.inputProblem,
         inputTraceMap: this.traceOverlapShiftSolver?.correctedTraceMap ?? Object.fromEntries(this.longDistancePairSolver.getOutput().allTracesMerged.map((p2) => [p2.mspPairId, p2]))
@@ -309670,7 +310350,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver4 {
     ], {
       onSolved: (_solver) => {}
     }),
-    definePipelineStep2("traceLabelOverlapAvoidanceSolver", TraceLabelOverlapAvoidanceSolver, (instance) => {
+    definePipelineStep22("traceLabelOverlapAvoidanceSolver", TraceLabelOverlapAvoidanceSolver, (instance) => {
       const traceMap = instance.traceOverlapShiftSolver?.correctedTraceMap ?? Object.fromEntries(instance.longDistancePairSolver.getOutput().allTracesMerged.map((p2) => [p2.mspPairId, p2]));
       const traces = Object.values(traceMap);
       const netLabelPlacements = instance.netLabelPlacementSolver.netLabelPlacements;
@@ -309682,7 +310362,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver4 {
         }
       ];
     }),
-    definePipelineStep2("traceCleanupSolver", TraceCleanupSolver, (instance) => {
+    definePipelineStep22("traceCleanupSolver", TraceCleanupSolver, (instance) => {
       const prevSolverOutput = instance.traceLabelOverlapAvoidanceSolver.getOutput();
       const traces = prevSolverOutput.traces;
       const labelMergingOutput = instance.traceLabelOverlapAvoidanceSolver.labelMergingSolver.getOutput();
@@ -309696,7 +310376,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver4 {
         }
       ];
     }),
-    definePipelineStep2("netLabelPlacementSolver", NetLabelPlacementSolver, (instance) => {
+    definePipelineStep22("netLabelPlacementSolver", NetLabelPlacementSolver, (instance) => {
       const traces = instance.traceCleanupSolver?.getOutput().traces ?? instance.traceLabelOverlapAvoidanceSolver.getOutput().traces;
       return [
         {
@@ -338840,7 +339520,7 @@ svg-path-commander/dist/index.js:
 */
 
 // cli/check/routing-difficulty/register.ts
-import path50 from "node:path";
+import path51 from "node:path";
 var checkRoutingDifficulty = async (file) => {
   const resolvedInputFilePath = await resolveCheckInputFilePath(file);
   const circuitJson = await getCircuitJsonForCheck({
@@ -338854,7 +339534,7 @@ var checkRoutingDifficulty = async (file) => {
   const analysis = await analyzeRouting(circuitJson);
   const result = analysis.getString();
   if (!result) {
-    return `No congested regions in ${path50.basename(resolvedInputFilePath)}`;
+    return `No congested regions in ${path51.basename(resolvedInputFilePath)}`;
   }
   return result;
 };
@@ -341243,8 +341923,8 @@ class CapacitorOrientationSolver extends BaseSolver21 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/DecouplingCapacitorGroupingSolver/DecouplingCapacitorGroupingSolver.ts
-import { BaseSolver as BaseSolver22 } from "@tscircuit/solver-utils";
-class DecouplingCapacitorGroupingSolver extends BaseSolver22 {
+import { BaseSolver as BaseSolver23 } from "@tscircuit/solver-utils";
+class DecouplingCapacitorGroupingSolver extends BaseSolver23 {
   params;
   static MIN_BODY_GAP = 1;
   banks = [];
@@ -341388,8 +342068,8 @@ function getNetLabelBounds(label) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentNetLabelCollisionSolver/ComponentNetLabelCollisionSolver.ts
-import { BaseSolver as BaseSolver23 } from "@tscircuit/solver-utils";
-class ComponentNetLabelCollisionSolver extends BaseSolver23 {
+import { BaseSolver as BaseSolver24 } from "@tscircuit/solver-utils";
+class ComponentNetLabelCollisionSolver extends BaseSolver24 {
   params;
   placements;
   netLabelsByComponentId;
@@ -341713,8 +342393,8 @@ class ComponentNetLabelCollisionSolver extends BaseSolver23 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentPinAlignmentSolver/ComponentPinAlignmentSolver.ts
-import { BaseSolver as BaseSolver24 } from "@tscircuit/solver-utils";
-class ComponentPinAlignmentSolver extends BaseSolver24 {
+import { BaseSolver as BaseSolver25 } from "@tscircuit/solver-utils";
+class ComponentPinAlignmentSolver extends BaseSolver25 {
   static ALIGNMENT_EPSILON = 0.01;
   ctx;
   out;
@@ -341848,8 +342528,8 @@ class ComponentPinAlignmentSolver extends BaseSolver24 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CrystalLoadCapacitorPlacementSolver/CrystalLoadCapacitorPlacementSolver.ts
-import { BaseSolver as BaseSolver25 } from "@tscircuit/solver-utils";
-class CrystalLoadCapacitorPlacementSolver extends BaseSolver25 {
+import { BaseSolver as BaseSolver26 } from "@tscircuit/solver-utils";
+class CrystalLoadCapacitorPlacementSolver extends BaseSolver26 {
   static ALIGNMENT_TOLERANCE = 0.1;
   issues;
   networks;
@@ -342009,9 +342689,9 @@ var distance51 = (first, second) => Math.hypot(first.schX - second.schX, first.s
 var round2 = (value) => Math.round(value * 100) / 100;
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/DiodeResistorAlignmentSolver/DiodeResistorAlignmentSolver.ts
-import { BaseSolver as BaseSolver26 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver27 } from "@tscircuit/solver-utils";
 import { getSourcePortConnectivityMapFromCircuitJson as getSourcePortConnectivityMapFromCircuitJson2 } from "circuit-json-to-connectivity-map";
-class DiodeResistorAlignmentSolver extends BaseSolver26 {
+class DiodeResistorAlignmentSolver extends BaseSolver27 {
   static DIODE_FTYPES = new Set(["simple_led", "simple_diode"]);
   ctx;
   out;
@@ -342177,8 +342857,8 @@ class DiodeResistorAlignmentSolver extends BaseSolver26 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/FeedbackNetworkPlacementSolver/FeedbackNetworkPlacementSolver.ts
-import { BaseSolver as BaseSolver27 } from "@tscircuit/solver-utils";
-class FeedbackNetworkPlacementSolver extends BaseSolver27 {
+import { BaseSolver as BaseSolver28 } from "@tscircuit/solver-utils";
+class FeedbackNetworkPlacementSolver extends BaseSolver28 {
   static MIN_BODY_GAP = 4;
   index;
   amplifierIds;
@@ -342263,7 +342943,7 @@ function distanceBetweenBoxes(a, b) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/PullResistorPlacementSolver/PullResistorPlacementSolver.ts
-import { BaseSolver as BaseSolver28 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver29 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/switch-pull-resistor-pairs.ts
 function getSwitchPullResistorPairs(index) {
@@ -342327,7 +343007,7 @@ function getHorizontalPushbuttonComponentIds(index) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/PullResistorPlacementSolver/PullResistorPlacementSolver.ts
-class PullResistorPlacementSolver extends BaseSolver28 {
+class PullResistorPlacementSolver extends BaseSolver29 {
   static MIN_WRONG_SIDE_GAP = 1.5;
   index;
   resistorIds;
@@ -342427,8 +343107,8 @@ class PullResistorPlacementSolver extends BaseSolver28 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentRailOrientationSolver/TwoPinComponentRailOrientationSolver.ts
-import { BaseSolver as BaseSolver29 } from "@tscircuit/solver-utils";
-class TwoPinComponentRailOrientationSolver extends BaseSolver29 {
+import { BaseSolver as BaseSolver30 } from "@tscircuit/solver-utils";
+class TwoPinComponentRailOrientationSolver extends BaseSolver30 {
   static EPSILON = 0.01;
   index;
   powerNets;
@@ -342743,8 +343423,8 @@ var polygonBounds = (polygons) => {
 };
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxInnerLabelCollisionSolver/SchematicBoxInnerLabelCollisionSolver.ts
-import { BaseSolver as BaseSolver30 } from "@tscircuit/solver-utils";
-class SchematicBoxInnerLabelCollisionSolver extends BaseSolver30 {
+import { BaseSolver as BaseSolver31 } from "@tscircuit/solver-utils";
+class SchematicBoxInnerLabelCollisionSolver extends BaseSolver31 {
   params;
   entries;
   placementById;
@@ -342849,8 +343529,8 @@ class SchematicBoxInnerLabelCollisionSolver extends BaseSolver30 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxOverlapSolver/SchematicBoxOverlapSolver.ts
-import { BaseSolver as BaseSolver31 } from "@tscircuit/solver-utils";
-class SchematicBoxOverlapSolver extends BaseSolver31 {
+import { BaseSolver as BaseSolver33 } from "@tscircuit/solver-utils";
+class SchematicBoxOverlapSolver extends BaseSolver33 {
   params;
   placements;
   firstIndex = 0;
@@ -343109,8 +343789,8 @@ function contentsFit(resized, ports, labelBankGap = INNER_LABEL_COLLISION_PADDIN
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicBoxTooWideSolver/SchematicBoxTooWideSolver.ts
-import { BaseSolver as BaseSolver32 } from "@tscircuit/solver-utils";
-class SchematicBoxTooWideSolver extends BaseSolver32 {
+import { BaseSolver as BaseSolver34 } from "@tscircuit/solver-utils";
+class SchematicBoxTooWideSolver extends BaseSolver34 {
   params;
   SCHEMATIC_BOX_TOO_WIDE_MESSAGE = "Shrink schematic box width";
   PIN_HEADER_MAX_ALLOWED_GAP = 0.1;
@@ -343270,8 +343950,8 @@ class SchematicBoxTooWideSolver extends BaseSolver32 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicPinPaddingToEdgeSolver/SchematicPinPaddingToEdgeSolver.ts
-import { BaseSolver as BaseSolver33 } from "@tscircuit/solver-utils";
-class SchematicPinPaddingToEdgeSolver extends BaseSolver33 {
+import { BaseSolver as BaseSolver35 } from "@tscircuit/solver-utils";
+class SchematicPinPaddingToEdgeSolver extends BaseSolver35 {
   params;
   MESSAGE = "Move schematic pins closer to the box edge or change the schematic box";
   GAP_COMPARISON_EPSILON = 0.000000001;
@@ -343534,7 +344214,7 @@ class SchematicPinPaddingToEdgeSolver extends BaseSolver33 {
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicPlacementPipeline/SchematicPlacementPipeline.ts
 import {
-  BasePipelineSolver as BasePipelineSolver2,
+  BasePipelineSolver as BasePipelineSolver3,
   definePipelineStep as definePipelineStep3
 } from "@tscircuit/solver-utils";
 
@@ -343642,8 +344322,8 @@ var buildSolverContext = (circuitJson) => {
 };
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SwitchPullResistorPlacementSolver/SwitchPullResistorPlacementSolver.ts
-import { BaseSolver as BaseSolver34 } from "@tscircuit/solver-utils";
-class SwitchPullResistorPlacementSolver extends BaseSolver34 {
+import { BaseSolver as BaseSolver36 } from "@tscircuit/solver-utils";
+class SwitchPullResistorPlacementSolver extends BaseSolver36 {
   params;
   constructor(params2) {
     super();
@@ -343712,8 +344392,8 @@ function getTraceName(circuitJson, trace) {
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TraceSimplificationSolver/TraceSimplificationSolver.ts
 import { calculateElbow as calculateElbow2 } from "calculate-elbow/lib";
-import { BaseSolver as BaseSolver35 } from "@tscircuit/solver-utils";
-class TraceSimplificationSolver extends BaseSolver35 {
+import { BaseSolver as BaseSolver37 } from "@tscircuit/solver-utils";
+class TraceSimplificationSolver extends BaseSolver37 {
   static EPSILON = 0.01;
   ctx;
   out;
@@ -344071,7 +344751,7 @@ class TraceSimplificationSolver extends BaseSolver35 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentOrientationSolver/TwoPinComponentOrientationSolver.ts
-import { BaseSolver as BaseSolver36 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver38 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentOrientationSolver/getPowerOrGroundConnectionIds.ts
 import {
@@ -344110,7 +344790,7 @@ function getPowerOrGroundConnectionIds(circuitJson) {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/TwoPinComponentOrientationSolver/TwoPinComponentOrientationSolver.ts
-class TwoPinComponentOrientationSolver extends BaseSolver36 {
+class TwoPinComponentOrientationSolver extends BaseSolver38 {
   static EPSILON = 0.01;
   ctx;
   out;
@@ -344356,8 +345036,8 @@ class TwoPinComponentOrientationSolver extends BaseSolver36 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/VerboseNetLabelSolver/VerboseNetLabelSolver.ts
-import { BaseSolver as BaseSolver37 } from "@tscircuit/solver-utils";
-class VerboseNetLabelSolver extends BaseSolver37 {
+import { BaseSolver as BaseSolver39 } from "@tscircuit/solver-utils";
+class VerboseNetLabelSolver extends BaseSolver39 {
   params;
   VERBOSE_NET_LABEL_MESSAGE = "Create trace with schDisplayLabel";
   netLabels;
@@ -344466,8 +345146,8 @@ class VerboseNetLabelSolver extends BaseSolver37 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicTextClearanceSolver/SchematicTextClearanceSolver.ts
-import { BaseSolver as BaseSolver38 } from "@tscircuit/solver-utils";
-class SchematicTextClearanceSolver extends BaseSolver38 {
+import { BaseSolver as BaseSolver40 } from "@tscircuit/solver-utils";
+class SchematicTextClearanceSolver extends BaseSolver40 {
   params;
   texts;
   obstacles;
@@ -344619,8 +345299,8 @@ class SchematicTextClearanceSolver extends BaseSolver38 {
 }
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ResetNetworkGroupingSolver/ResetNetworkGroupingSolver.ts
-import { BaseSolver as BaseSolver39 } from "@tscircuit/solver-utils";
-class ResetNetworkGroupingSolver extends BaseSolver39 {
+import { BaseSolver as BaseSolver41 } from "@tscircuit/solver-utils";
+class ResetNetworkGroupingSolver extends BaseSolver41 {
   params;
   static MIN_DISTANCE = 6;
   networks;
@@ -344826,7 +345506,7 @@ var solversByIssueType = {
   ]
 };
 
-class SchematicPlacementPipeline extends BasePipelineSolver2 {
+class SchematicPlacementPipeline extends BasePipelineSolver3 {
   ctx;
   issues = [];
   pipelineDef = [
@@ -345463,8 +346143,8 @@ var registerCheckSchematicPlacement = (program) => {
 };
 
 // cli/check/shorts/register.ts
-import { mkdir as mkdir2, writeFile } from "node:fs/promises";
-import path51 from "node:path";
+import { mkdir as mkdir3, writeFile as writeFile2 } from "node:fs/promises";
+import path52 from "node:path";
 import { all_layers as all_layers2, layer_string } from "circuit-json";
 
 // cli/check/shorts/get-check-short-layers.ts
@@ -345550,8 +346230,8 @@ var formatShort = (short, index) => {
   ].join(`
 `);
 };
-var getShortArtifactOutputPath = () => path51.resolve(process.cwd(), "checks", "check-shorts", "bitmap.png");
-var getShortPcbSnapshotOutputPath = () => path51.resolve(process.cwd(), "checks", "check-shorts", "pcb.svg");
+var getShortArtifactOutputPath = () => path52.resolve(process.cwd(), "checks", "check-shorts", "bitmap.png");
+var getShortPcbSnapshotOutputPath = () => path52.resolve(process.cwd(), "checks", "check-shorts", "pcb.svg");
 var checkShorts = async (file, options = {}) => {
   const resolvedInputFilePath = await resolveCheckInputFilePath(file);
   const mode = parseMode(options.mode);
@@ -345578,7 +346258,7 @@ var checkShorts = async (file, options = {}) => {
     pixelsPerMm
   })));
   const shorts = debugRenders.flatMap((debugRender) => debugRender.shorts);
-  const filename = path51.basename(resolvedInputFilePath);
+  const filename = path52.basename(resolvedInputFilePath);
   if (shorts.length === 0) {
     return {
       output: `No shorts detected in ${filename}`,
@@ -345617,8 +346297,8 @@ var registerCheckShorts = (program) => {
       if (result.artifacts) {
         for (const artifact of result.artifacts) {
           const outputPath = artifact.defaultOutputPath;
-          await mkdir2(path51.dirname(outputPath), { recursive: true });
-          await writeFile(outputPath, artifact.content);
+          await mkdir3(path52.dirname(outputPath), { recursive: true });
+          await writeFile2(outputPath, artifact.content);
           console.log(`Short debug artifact written to ${outputPath}`);
         }
       }
@@ -345664,16 +346344,16 @@ var registerCheckSource = (program) => {
 };
 
 // cli/check/trace-length/register.ts
-import path52 from "node:path";
+import path53 from "node:path";
 var loadTraceLengthAnalyzer = async () => {
-  const mod = await Promise.resolve().then(() => (init_lib2(), {}));
+  const mod = await Promise.resolve().then(() => (init_lib3(), {}));
   return analyzeCircuitJsonTraceLength;
 };
 var getAutorouterDiagnosticsOptions = (options = {}) => {
   const timeoutMs = options.autorouterTimeout ? parseAutorouterTimeout(options.autorouterTimeout) : undefined;
   const phaseName = options.autorouterPhase !== undefined ? parseAutorouterPhaseName(options.autorouterPhase) : undefined;
   const dumpSrj = parseAutorouterDumpSrjMode(options.autorouterDumpSrj);
-  const debugDir = options.autorouterDebugDir ? path52.resolve(process.cwd(), options.autorouterDebugDir) : path52.resolve(process.cwd(), "dist", "autorouter-debug");
+  const debugDir = options.autorouterDebugDir ? path53.resolve(process.cwd(), options.autorouterDebugDir) : path53.resolve(process.cwd(), "dist", "autorouter-debug");
   return {
     enabled: options.autorouterDebug || phaseName !== undefined,
     phaseName,
@@ -345715,25 +346395,25 @@ var registerCheckTraceLength = (program) => {
 
 // cli/clone/register.ts
 import * as fs49 from "node:fs";
-import * as path55 from "node:path";
+import * as path56 from "node:path";
 
 // cli/clone/clone-bug-report.ts
 var import_jszip3 = __toESM3(require_lib4(), 1);
 var import_prompts5 = __toESM3(require_prompts3(), 1);
 import * as fs48 from "node:fs";
-import * as path54 from "node:path";
+import * as path55 from "node:path";
 
 // cli/clone/handle-existing-directory.ts
 var import_prompts4 = __toESM3(require_prompts3(), 1);
 import * as fs47 from "node:fs";
-import * as path53 from "node:path";
+import * as path54 from "node:path";
 var handleExistingDirectory = async (dirPath) => {
   if (!fs47.existsSync(dirPath))
     return;
   const response = await import_prompts4.default({
     type: "select",
     name: "action",
-    message: `Directory "${path53.basename(dirPath)}" already exists. What would you like to do?`,
+    message: `Directory "${path54.basename(dirPath)}" already exists. What would you like to do?`,
     choices: [
       { title: "Merge files into existing directory", value: "merge" },
       {
@@ -345774,12 +346454,12 @@ var getCommonDirectoryPrefix = (paths) => {
   return commonSegments.join("/");
 };
 var sanitizeRelativePath = (relativePath) => {
-  const normalizedPath = path54.normalize(relativePath);
+  const normalizedPath = path55.normalize(relativePath);
   if (!normalizedPath)
     return null;
-  if (path54.isAbsolute(normalizedPath))
+  if (path55.isAbsolute(normalizedPath))
     return null;
-  const segments = normalizedPath.split(path54.sep);
+  const segments = normalizedPath.split(path55.sep);
   if (segments.some((segment) => segment === ".." || segment === "")) {
     return null;
   }
@@ -345794,7 +346474,7 @@ var cloneBugReport = async ({
     console.error("Bug report ID must not be empty.");
     process.exit(1);
   }
-  let dirPath = path54.resolve(`bug-report-${trimmedBugReportId}`);
+  let dirPath = path55.resolve(`bug-report-${trimmedBugReportId}`);
   await handleExistingDirectory(dirPath);
   const ky = getRegistryApiKy();
   let zipBuffer;
@@ -345824,25 +346504,25 @@ var cloneBugReport = async ({
       console.warn(`Skipping potentially unsafe path: ${fileName}`);
       continue;
     }
-    const fullPath = path54.join(dirPath, sanitizedRelativePath);
-    fs48.mkdirSync(path54.dirname(fullPath), { recursive: true });
+    const fullPath = path55.join(dirPath, sanitizedRelativePath);
+    fs48.mkdirSync(path55.dirname(fullPath), { recursive: true });
     const fileContent = await entry.async("nodebuffer");
     fs48.writeFileSync(fullPath, fileContent);
   }
-  const packageJsonPath = path54.join(dirPath, "package.json");
+  const packageJsonPath = path55.join(dirPath, "package.json");
   if (fs48.existsSync(packageJsonPath)) {
     try {
       const packageJson = JSON.parse(fs48.readFileSync(packageJsonPath, "utf-8"));
       const packageName = packageJson?.name;
       if (typeof packageName === "string" && packageName.trim()) {
         const sanitizedName = packageName.replace(/[^a-zA-Z0-9]/g, "_");
-        const suggestedDirPath = path54.resolve(`${sanitizedName}_${trimmedBugReportId.slice(7)}`);
+        const suggestedDirPath = path55.resolve(`${sanitizedName}_${trimmedBugReportId.slice(7)}`);
         if (suggestedDirPath !== dirPath) {
           const response = await import_prompts5.default({
             type: "confirm",
             name: "rename",
             initial: true,
-            message: `Rename the directory to "${path54.basename(suggestedDirPath)}"?`
+            message: `Rename the directory to "${path55.basename(suggestedDirPath)}"?`
           });
           if (response.rename) {
             await handleExistingDirectory(suggestedDirPath);
@@ -345855,9 +346535,9 @@ var cloneBugReport = async ({
       console.warn("Unable to read package name for renaming:", error);
     }
   }
-  fs48.writeFileSync(path54.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
+  fs48.writeFileSync(path55.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
   generateTsConfig(dirPath);
-  const relativeDirPath = path54.relative(originalCwd, dirPath);
+  const relativeDirPath = path55.relative(originalCwd, dirPath);
   console.log(kleur_default.green(`
 Successfully cloned bug report to:`));
   console.log(`  ${dirPath}/
@@ -345896,7 +346576,7 @@ var registerClone = (program) => {
     const [, author, packageName] = match;
     console.log(`Cloning ${author}/${packageName}...`);
     const userSettingToIncludeAuthor = options.includeAuthor || cliConfig.get("alwaysCloneWithAuthorName");
-    const dirPath = userSettingToIncludeAuthor ? path55.resolve(`${author}.${packageName}`) : path55.resolve(packageName);
+    const dirPath = userSettingToIncludeAuthor ? path56.resolve(`${author}.${packageName}`) : path56.resolve(packageName);
     await handleExistingDirectory(dirPath);
     const ky = getRegistryApiKy();
     let packageFileList = {
@@ -345922,8 +346602,8 @@ var registerClone = (program) => {
       const filePath = fileInfo.file_path.replace(/^\/+/, "");
       if (!filePath)
         continue;
-      const fullPath = path55.join(dirPath, filePath);
-      fs49.mkdirSync(path55.dirname(fullPath), { recursive: true });
+      const fullPath = path56.join(dirPath, filePath);
+      fs49.mkdirSync(path56.dirname(fullPath), { recursive: true });
       try {
         const fileContent = await ky.get("package_files/get", {
           searchParams: {
@@ -345949,10 +346629,10 @@ var registerClone = (program) => {
         console.warn(`Skipping ${filePath} due to error:`, error instanceof Error ? error.message : error);
       }
     }
-    fs49.writeFileSync(path55.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
+    fs49.writeFileSync(path56.join(dirPath, ".npmrc"), "@tsci:registry=https://npm.tscircuit.com");
     generateTsConfig(dirPath);
     await setupTsciProject(dirPath);
-    const relativeDirPath = path55.relative(originalCwd, dirPath);
+    const relativeDirPath = path56.relative(originalCwd, dirPath);
     console.log(kleur_default.green(`
 Successfully cloned to:`));
     console.log(`  ${dirPath}/
@@ -346019,7 +346699,7 @@ var registerConfigSet = (program) => {
 };
 
 // cli/convert/register.ts
-import path60 from "node:path";
+import path61 from "node:path";
 
 // node_modules/@tscircuit/mm/dist/index.js
 var unitToMm2 = {
@@ -346931,16 +347611,16 @@ var convertCircuitJsonToTscircuit = (circuitJson, opts) => {
 
 // cli/convert/convert-kicad-footprint-to-tsx.ts
 import fs51 from "node:fs/promises";
-import path57 from "node:path";
+import path58 from "node:path";
 
 // cli/convert/convert-kicad-footprint-to-circuit-json.ts
 import fs50 from "node:fs/promises";
-import path56 from "node:path";
+import path57 from "node:path";
 import { KicadFootprintToCircuitJsonConverter } from "kicad-to-circuit-json";
 var convertKicadFootprintToCircuitJson = async (inputPath) => {
   const modContent = await fs50.readFile(inputPath, "utf-8");
   const converter = new KicadFootprintToCircuitJsonConverter;
-  converter.addFile(path56.basename(inputPath), modContent);
+  converter.addFile(path57.basename(inputPath), modContent);
   converter.runUntilFinished();
   return converter.getOutput();
 };
@@ -346952,9 +347632,9 @@ var convertKicadFootprintToTsx = async ({
   output
 }) => {
   const circuitJson = await convertKicadFootprintToCircuitJson(inputPath);
-  const componentName = name ?? path57.basename(inputPath, ".kicad_mod");
+  const componentName = name ?? path58.basename(inputPath, ".kicad_mod");
   const tsx = convertCircuitJsonToTscircuit(circuitJson, { componentName });
-  const outputPath = output ? path57.resolve(output) : path57.join(path57.dirname(inputPath), `${componentName}.tsx`);
+  const outputPath = output ? path58.resolve(output) : path58.join(path58.dirname(inputPath), `${componentName}.tsx`);
   await fs51.writeFile(outputPath, tsx);
   console.log(kleur_default.green(`Converted ${outputPath}`));
 };
@@ -353076,14 +353756,14 @@ var circuitJsonToFootprinter2 = circuitJsonToFootprinter;
 
 // cli/convert/discover-footprinter-from-file.ts
 import fs53 from "node:fs/promises";
-import path59 from "node:path";
+import path60 from "node:path";
 
 // cli/convert/load-circuit-json-for-footprinter.ts
 import fs52 from "node:fs/promises";
-import path58 from "node:path";
+import path59 from "node:path";
 var componentExtensions = new Set([".js", ".jsx", ".ts", ".tsx"]);
 var loadCircuitJsonForFootprinter = async (inputPath) => {
-  const extension = path58.extname(inputPath).toLowerCase();
+  const extension = path59.extname(inputPath).toLowerCase();
   if (inputPath.toLowerCase().endsWith(".circuit.json")) {
     const parsed = JSON.parse(await fs52.readFile(inputPath, "utf-8"));
     if (!Array.isArray(parsed)) {
@@ -353120,7 +353800,7 @@ var discoverFootprinterFromFile = async ({
   const circuitJson = await loadCircuitJsonForFootprinter(inputPath);
   const inputText = await fs53.readFile(inputPath, "utf-8");
   const result = circuitJsonToFootprinter2(circuitJson, {
-    sourceHints: [path59.basename(inputPath), inputText.slice(0, 20000)]
+    sourceHints: [path60.basename(inputPath), inputText.slice(0, 20000)]
   });
   if (!result.best) {
     throw new Error("No compatible footprinter string was found");
@@ -353131,7 +353811,7 @@ var discoverFootprinterFromFile = async ({
     diagnostics: result.diagnostics
   }, null, 2) : result.best.footprinterString;
   if (output) {
-    const outputPath = path59.resolve(output);
+    const outputPath = path60.resolve(output);
     await fs53.writeFile(outputPath, `${resultText}
 `);
     console.log(kleur_default.green(`Converted ${outputPath}`));
@@ -353147,8 +353827,8 @@ var discoverFootprinterFromFile = async ({
 var registerConvert = (program) => {
   program.command("convert").description("Convert .kicad_mod to TSX, or discover a footprinter string with --footprinter").argument("<file>", "Path to .kicad_mod, TSX component, or Circuit JSON").option("-o, --output <path>", "Output TSX, footprinter, or JSON path").option("-n, --name <component>", "TSX component name for .kicad_mod conversion").option("--footprinter", "Discover a footprinter string instead of converting to TSX").option("--json", "Output footprinter discovery details as JSON (requires --footprinter)").action(async (file, options) => {
     try {
-      const inputPath = path60.resolve(file);
-      const extension = path60.extname(inputPath).toLowerCase();
+      const inputPath = path61.resolve(file);
+      const extension = path61.extname(inputPath).toLowerCase();
       if (options.json && !options.footprinter) {
         throw new Error("--json requires --footprinter");
       }
@@ -353178,11 +353858,11 @@ var registerConvert = (program) => {
 // cli/dev/register.ts
 import * as fs60 from "node:fs";
 import * as net from "node:net";
-import * as path69 from "node:path";
+import * as path70 from "node:path";
 
 // cli/dev/resolve-dev-target.ts
 import * as fs54 from "node:fs";
-import * as path61 from "node:path";
+import * as path62 from "node:path";
 var findSelectableFiles = (projectDir) => {
   const boardFiles = findBoardFiles({ projectDir }).filter((file) => fs54.existsSync(file)).sort();
   if (boardFiles.length > 0) {
@@ -353192,15 +353872,15 @@ var findSelectableFiles = (projectDir) => {
     cwd: projectDir,
     ignore: DEFAULT_IGNORED_PATTERNS
   });
-  return files.map((file) => path61.resolve(projectDir, file)).filter((file) => fs54.existsSync(file)).sort();
+  return files.map((file) => path62.resolve(projectDir, file)).filter((file) => fs54.existsSync(file)).sort();
 };
 var isValidDevFile = (filePath) => {
   return filePath.endsWith(".tsx") || filePath.endsWith(".ts") || isCircuitJsonFile(filePath);
 };
 var resolveDevTarget = async (file, cwd = process.cwd()) => {
-  let projectDir = path61.resolve(cwd);
+  let projectDir = path62.resolve(cwd);
   if (file) {
-    const resolvedPath = path61.resolve(projectDir, file);
+    const resolvedPath = path62.resolve(projectDir, file);
     if (fs54.existsSync(resolvedPath) && fs54.statSync(resolvedPath).isDirectory()) {
       projectDir = resolvedPath;
       const availableFiles = findSelectableFiles(projectDir);
@@ -353208,7 +353888,7 @@ var resolveDevTarget = async (file, cwd = process.cwd()) => {
         console.log(`No .tsx, .ts, .circuit.json, or circuit.json files found in ${projectDir}. Run 'tsci init' to bootstrap a basic project.`);
         return null;
       }
-      console.log("Selected file:", path61.relative(projectDir, availableFiles[0]));
+      console.log("Selected file:", path62.relative(projectDir, availableFiles[0]));
       return { absolutePath: availableFiles[0], projectDir };
     }
     if (!fs54.existsSync(resolvedPath)) {
@@ -353234,13 +353914,13 @@ var resolveDevTarget = async (file, cwd = process.cwd()) => {
     console.log("No .tsx, .ts, .circuit.json, or circuit.json files found in the project. Run 'tsci init' to bootstrap a basic project.");
     return null;
   }
-  console.log("Selected file:", path61.relative(projectDir, availableFiles[0]));
+  console.log("Selected file:", path62.relative(projectDir, availableFiles[0]));
   return { absolutePath: availableFiles[0], projectDir };
 };
 
 // lib/dev/DevServer.ts
 import fs59 from "node:fs";
-import path68 from "node:path";
+import path69 from "node:path";
 
 // node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
@@ -354815,10 +355495,10 @@ import Debug3 from "debug";
 
 // lib/dependency-analysis/getNodeModuleDependencies.ts
 import * as ts4 from "typescript";
-import * as path62 from "path";
+import * as path63 from "path";
 import * as fs55 from "fs";
 function getAllDependencyPackages(projectDir) {
-  const packageJsonPath = path62.join(projectDir, "package.json");
+  const packageJsonPath = path63.join(projectDir, "package.json");
   const allPackages = new Set;
   if (!fs55.existsSync(packageJsonPath)) {
     return allPackages;
@@ -354839,7 +355519,7 @@ function getAllDependencyPackages(projectDir) {
   return allPackages;
 }
 function getNodeModuleImports(filePath) {
-  const absolutePath = path62.resolve(filePath);
+  const absolutePath = path63.resolve(filePath);
   if (!fs55.existsSync(absolutePath)) {
     return [];
   }
@@ -354893,17 +355573,17 @@ function resolveNodeModuleImport({
 }) {
   const packageName = getPackageNameFromImport(importPath);
   const searchPaths = [
-    path62.join(projectDir, "node_modules", packageName)
+    path63.join(projectDir, "node_modules", packageName)
   ];
   if (searchFromDir) {
-    let currentDir = path62.dirname(searchFromDir);
-    const projectDirNormalized = path62.normalize(projectDir);
+    let currentDir = path63.dirname(searchFromDir);
+    const projectDirNormalized = path63.normalize(projectDir);
     while (currentDir.startsWith(projectDirNormalized)) {
-      const candidatePath = path62.join(currentDir, "node_modules", packageName);
+      const candidatePath = path63.join(currentDir, "node_modules", packageName);
       if (!searchPaths.includes(candidatePath)) {
         searchPaths.push(candidatePath);
       }
-      const parentDir = path62.dirname(currentDir);
+      const parentDir = path63.dirname(currentDir);
       if (parentDir === currentDir)
         break;
       currentDir = parentDir;
@@ -354919,22 +355599,22 @@ function resolveNodeModuleImport({
   if (!packageDir) {
     return [];
   }
-  const packageJsonPath = path62.join(packageDir, "package.json");
+  const packageJsonPath = path63.join(packageDir, "package.json");
   const hasPackageJson = fs55.existsSync(packageJsonPath);
   const packageJson = hasPackageJson ? JSON.parse(fs55.readFileSync(packageJsonPath, "utf-8")) : null;
   const resolvedFiles = [];
   if (importPath !== packageName) {
     const subpath = importPath.slice(packageName.length + 1);
     const possiblePaths = [
-      path62.join(packageDir, subpath),
-      path62.join(packageDir, `${subpath}.js`),
-      path62.join(packageDir, `${subpath}.mjs`),
-      path62.join(packageDir, `${subpath}.ts`),
-      path62.join(packageDir, `${subpath}.tsx`),
-      path62.join(packageDir, subpath, "index.js"),
-      path62.join(packageDir, subpath, "index.mjs"),
-      path62.join(packageDir, subpath, "index.ts"),
-      path62.join(packageDir, subpath, "index.tsx")
+      path63.join(packageDir, subpath),
+      path63.join(packageDir, `${subpath}.js`),
+      path63.join(packageDir, `${subpath}.mjs`),
+      path63.join(packageDir, `${subpath}.ts`),
+      path63.join(packageDir, `${subpath}.tsx`),
+      path63.join(packageDir, subpath, "index.js"),
+      path63.join(packageDir, subpath, "index.mjs"),
+      path63.join(packageDir, subpath, "index.ts"),
+      path63.join(packageDir, subpath, "index.tsx")
     ];
     for (const p of possiblePaths) {
       if (fs55.existsSync(p) && fs55.statSync(p).isFile()) {
@@ -354969,22 +355649,22 @@ function resolveNodeModuleImport({
     resolveExportValue(packageJson.exports?.["."]?.require)
   ].filter((entry) => typeof entry === "string");
   for (const entry of entryPoints) {
-    const entryPath = path62.join(packageDir, entry);
+    const entryPath = path63.join(packageDir, entry);
     if (fs55.existsSync(entryPath) && fs55.statSync(entryPath).isFile()) {
       resolvedFiles.push(entryPath);
     }
   }
   if (resolvedFiles.length === 0) {
     const fallbackPaths = [
-      path62.join(packageDir, "index.js"),
-      path62.join(packageDir, "index.mjs"),
-      path62.join(packageDir, "index.ts"),
-      path62.join(packageDir, "index.tsx"),
-      path62.join(packageDir, "dist", "index.js"),
-      path62.join(packageDir, "dist", "index.mjs"),
-      path62.join(packageDir, "lib", "index.js"),
-      path62.join(packageDir, "src", "index.ts"),
-      path62.join(packageDir, "src", "index.tsx")
+      path63.join(packageDir, "index.js"),
+      path63.join(packageDir, "index.mjs"),
+      path63.join(packageDir, "index.ts"),
+      path63.join(packageDir, "index.tsx"),
+      path63.join(packageDir, "dist", "index.js"),
+      path63.join(packageDir, "dist", "index.mjs"),
+      path63.join(packageDir, "lib", "index.js"),
+      path63.join(packageDir, "src", "index.ts"),
+      path63.join(packageDir, "src", "index.tsx")
     ];
     for (const p of fallbackPaths) {
       if (fs55.existsSync(p) && fs55.statSync(p).isFile()) {
@@ -355025,8 +355705,8 @@ function collectAllNodeModuleDependencies(entryFilePath, projectDir, maxDepth =
     }
   }
   function getLocalDependencies(filePath) {
-    const absolutePath = path62.resolve(filePath);
-    const baseDir = path62.dirname(absolutePath);
+    const absolutePath = path63.resolve(filePath);
+    const baseDir = path63.dirname(absolutePath);
     if (!fs55.existsSync(absolutePath)) {
       return [];
     }
@@ -355052,7 +355732,7 @@ function collectAllNodeModuleDependencies(entryFilePath, projectDir, maxDepth =
   }
   function resolveLocalImport(importPath, baseDir) {
     const extensions = [".tsx", ".ts", ".jsx", ".js", ".mjs"];
-    const resolvedPath = path62.resolve(baseDir, importPath);
+    const resolvedPath = path63.resolve(baseDir, importPath);
     if (fs55.existsSync(resolvedPath) && fs55.statSync(resolvedPath).isFile()) {
       return resolvedPath;
     }
@@ -355064,7 +355744,7 @@ function collectAllNodeModuleDependencies(entryFilePath, projectDir, maxDepth =
     }
     if (fs55.existsSync(resolvedPath) && fs55.statSync(resolvedPath).isDirectory()) {
       for (const ext of extensions) {
-        const indexPath = path62.join(resolvedPath, `index${ext}`);
+        const indexPath = path63.join(resolvedPath, `index${ext}`);
         if (fs55.existsSync(indexPath)) {
           return indexPath;
         }
@@ -355090,11 +355770,11 @@ var EXCLUDED_PACKAGE_DIRECTORIES = new Set([
 function collectLocalPackageFiles(packageDir) {
   const buildDirs = ["dist", "build"];
   for (const dirName of buildDirs) {
-    const dirPath = path62.join(packageDir, dirName);
+    const dirPath = path63.join(packageDir, dirName);
     if (fs55.existsSync(dirPath)) {
       const files = walkDirectory(dirPath, new Set);
       if (files.length > 0) {
-        const packageJsonPath = path62.join(packageDir, "package.json");
+        const packageJsonPath = path63.join(packageDir, "package.json");
         if (fs55.existsSync(packageJsonPath)) {
           files.push(packageJsonPath);
         }
@@ -355110,7 +355790,7 @@ function walkDirectory(dir, excludedDirs) {
     return files;
   const entries = fs55.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path62.join(dir, entry.name);
+    const fullPath = path63.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (excludedDirs.has(entry.name)) {
         continue;
@@ -355171,10 +355851,10 @@ function getAllNodeModuleFilePaths(entryFilePath, projectDir) {
       processedPackages.add(packageName);
       if (resolvedFiles.length > 0) {
         const firstResolvedFile = resolvedFiles[0];
-        let packageDir = path62.dirname(firstResolvedFile);
+        let packageDir = path63.dirname(firstResolvedFile);
         let hasPackageJson = false;
         while (packageDir.includes("node_modules")) {
-          const packageJsonPath = path62.join(packageDir, "package.json");
+          const packageJsonPath = path63.join(packageDir, "package.json");
           if (fs55.existsSync(packageJsonPath)) {
             try {
               const pkgJson = JSON.parse(fs55.readFileSync(packageJsonPath, "utf-8"));
@@ -355185,10 +355865,10 @@ function getAllNodeModuleFilePaths(entryFilePath, projectDir) {
             } catch {}
           }
           const expectedPackagePath = packageName.startsWith("@") ? `node_modules/${packageName}` : `node_modules/${packageName}`;
-          if (packageDir.endsWith(expectedPackagePath) || packageDir.endsWith(expectedPackagePath.replace(/\//g, path62.sep))) {
+          if (packageDir.endsWith(expectedPackagePath) || packageDir.endsWith(expectedPackagePath.replace(/\//g, path63.sep))) {
             break;
           }
-          const parentDir = path62.dirname(packageDir);
+          const parentDir = path63.dirname(packageDir);
           if (parentDir === packageDir)
             break;
           packageDir = parentDir;
@@ -355262,7 +355942,7 @@ class EventsWatcher extends EventEmitter2 {
 import * as fs57 from "node:fs";
 import * as http from "node:http";
 import { createRequire as createRequire5 } from "node:module";
-import * as path64 from "node:path";
+import * as path65 from "node:path";
 
 // node_modules/winterspec/dist/edge/transform-to-node.js
 var import_node_utils = __toESM3(require_dist7(), 1);
@@ -356825,13 +357505,13 @@ var getIndex = async (mainComponentPath, fileServerApiBaseUrl) => {
 
 // lib/server/kicad-pcm-proxy.ts
 import * as fs56 from "node:fs";
-import * as path63 from "node:path";
+import * as path64 from "node:path";
 var getSourceFilesChecksum = (projectDir) => {
   const sourceFiles = globbySync(["**/*.tsx", "**/*.ts", "**/*.json", "!node_modules/**", "!dist/**"], { cwd: projectDir });
   let checksum = "";
   for (const file of sourceFiles) {
     try {
-      const stat = fs56.statSync(path63.join(projectDir, file));
+      const stat = fs56.statSync(path64.join(projectDir, file));
       checksum += `${file}:${stat.mtimeMs};`;
     } catch {}
   }
@@ -356851,9 +357531,9 @@ var createKicadPcmProxy = ({
   };
   const handleRequest = async (url, res) => {
     const requestedFile = url.pathname.replace(/^\/pcm\/?/, "") || "repository.json";
-    const distDir = path63.join(projectDir, "dist");
-    const pcmDir = path63.join(distDir, "pcm");
-    const filePath = path63.join(pcmDir, requestedFile);
+    const distDir = path64.join(projectDir, "dist");
+    const pcmDir = path64.join(distDir, "pcm");
+    const filePath = path64.join(pcmDir, requestedFile);
     const currentChecksum = getSourceFilesChecksum(projectDir);
     const needsRebuild = currentChecksum !== pcmState.lastFileChecksum;
     if (needsRebuild) {
@@ -356903,7 +357583,7 @@ Rebuilding KiCad PCM assets...`));
       res.end(`PCM file not found: ${requestedFile}`);
       return;
     }
-    const ext = path63.extname(filePath).toLowerCase();
+    const ext = path64.extname(filePath).toLowerCase();
     let contentType = "application/octet-stream";
     if (ext === ".json") {
       contentType = "application/json";
@@ -356928,7 +357608,7 @@ var resolveLocalTscircuitStandalonePath = (projectDir) => {
   if (!projectDir)
     return;
   try {
-    const projectRequire = createRequire5(path64.join(projectDir, "package.json"));
+    const projectRequire = createRequire5(path65.join(projectDir, "package.json"));
     const browserBundlePath = projectRequire.resolve("tscircuit/browser");
     if (fs57.existsSync(browserBundlePath))
       return browserBundlePath;
@@ -356950,7 +357630,7 @@ var createHttpServer = async ({
   entryFile
 }) => {
   const fileServerHandler = getNodeHandler(stdin_default, {});
-  const localCacheEngine = projectDir ? createLocalCacheEngine(path64.join(projectDir, ".tscircuit", "cache")) : undefined;
+  const localCacheEngine = projectDir ? createLocalCacheEngine(path65.join(projectDir, ".tscircuit", "cache")) : undefined;
   const pcmProxy = kicadPcm && projectDir && entryFile ? createKicadPcmProxy({ projectDir, entryFile, port }) : null;
   const server = http.createServer(async (req, res) => {
     const requestHost = req.headers.host ?? `localhost:${port}`;
@@ -357108,7 +357788,7 @@ var createHttpServer = async ({
 // lib/shared/push-snippet.ts
 var import_semver6 = __toESM3(require_semver2(), 1);
 import * as fs58 from "node:fs";
-import * as path67 from "node:path";
+import * as path68 from "node:path";
 import Debug2 from "debug";
 
 // lib/utils/validate-package-name.ts
@@ -357126,7 +357806,7 @@ var validatePackageName = (name) => {
 };
 
 // lib/dev/get-package-file-paths.ts
-import * as path65 from "node:path";
+import * as path66 from "node:path";
 var getPackageFilePaths = (projectDir, ignored = []) => {
   const ignorePatterns = [
     ...DEFAULT_IGNORED_PATTERNS,
@@ -357137,7 +357817,7 @@ var getPackageFilePaths = (projectDir, ignored = []) => {
     ignore: ignorePatterns
   });
   fileNames.sort();
-  return fileNames.map((fileName) => path65.join(projectDir, fileName));
+  return fileNames.map((fileName) => path66.join(projectDir, fileName));
 };
 
 // lib/utils/check-org-access.ts
@@ -357153,7 +357833,7 @@ var checkOrgAccess = async (ky, orgTscircuitHandle) => {
 };
 
 // lib/shared/is-binary-file.ts
-import * as path66 from "node:path";
+import * as path67 from "node:path";
 var BINARY_FILE_EXTENSIONS = new Set([
   ".glb",
   ".gltf",
@@ -357169,7 +357849,7 @@ var BINARY_FILE_EXTENSIONS = new Set([
   ".tar"
 ]);
 var isBinaryFile = (filePath) => {
-  const ext = path66.extname(filePath).toLowerCase();
+  const ext = path67.extname(filePath).toLowerCase();
   return BINARY_FILE_EXTENSIONS.has(ext);
 };
 
@@ -357206,14 +357886,14 @@ var findPushProject = async ({
       return null;
     }
     const packageJsonPath = [
-      path67.resolve(path67.join(path67.dirname(snippetFilePath), "package.json")),
-      path67.resolve(path67.join(process.cwd(), "package.json"))
+      path68.resolve(path68.join(path68.dirname(snippetFilePath), "package.json")),
+      path68.resolve(path68.join(process.cwd(), "package.json"))
     ].find((candidatePath) => fs58.existsSync(candidatePath));
-    const projectDir = packageJsonPath ? path67.dirname(packageJsonPath) : path67.dirname(snippetFilePath);
+    const projectDir = packageJsonPath ? path68.dirname(packageJsonPath) : path68.dirname(snippetFilePath);
     return { snippetFilePath, packageJsonPath, projectDir };
   }
   const projectDir = process.cwd();
-  const packageJsonPath = path67.resolve(path67.join(projectDir, "package.json"));
+  const packageJsonPath = path68.resolve(path68.join(projectDir, "package.json"));
   if (!fs58.existsSync(packageJsonPath)) {
     return { projectDir };
   }
@@ -357226,7 +357906,7 @@ var findPushProject = async ({
 };
 var getArchivePayload = (filePaths, projectDir, packageNameWithVersion) => {
   const files = filePaths.map((fullFilePath) => {
-    const relativeFilePath = path67.relative(projectDir, fullFilePath);
+    const relativeFilePath = path68.relative(projectDir, fullFilePath);
     const fileBuffer = fs58.readFileSync(fullFilePath);
     const isBinary = isBinaryFile(relativeFilePath) || hasBinaryContent(fileBuffer);
     return isBinary ? {
@@ -357460,7 +358140,7 @@ var pushSnippet = async ({
         json: archivePayload
       });
       for (const fullFilePath of filePaths) {
-        const relativeFilePath = path67.relative(projectDir, fullFilePath);
+        const relativeFilePath = path68.relative(projectDir, fullFilePath);
         uploadResults.succeeded.push(relativeFilePath);
       }
       log(kleur_default.gray(`\uD83D\uDCE6 Uploaded archive with ${filePaths.length} files`));
@@ -357470,7 +358150,7 @@ var pushSnippet = async ({
   }
   if (uploadResults.succeeded.length === 0) {
     for (const fullFilePath of filePaths) {
-      const relativeFilePath = path67.relative(projectDir, fullFilePath);
+      const relativeFilePath = path68.relative(projectDir, fullFilePath);
       const fileBuffer = fs58.readFileSync(fullFilePath);
       const isBinary = isBinaryFile(relativeFilePath) || hasBinaryContent(fileBuffer);
       const payload = {
@@ -357590,7 +358270,7 @@ class DevServer {
   }) {
     this.port = port;
     this.componentFilePath = componentFilePath;
-    this.projectDir = projectDir ?? path68.dirname(componentFilePath);
+    this.projectDir = projectDir ?? path69.dirname(componentFilePath);
     this.kicadPcm = kicadPcm ?? false;
     this.autorouterDebug = autorouterDebug ?? false;
     this.autorouterPhase = autorouterPhase?.trim() || undefined;
@@ -357603,7 +358283,7 @@ class DevServer {
   async start() {
     const { server } = await createHttpServer({
       port: this.port,
-      defaultMainComponentPath: path68.relative(this.projectDir, this.componentFilePath),
+      defaultMainComponentPath: path69.relative(this.projectDir, this.componentFilePath),
       kicadPcm: this.kicadPcm,
       projectDir: this.projectDir,
       entryFile: this.componentFilePath
@@ -357631,7 +358311,7 @@ class DevServer {
     this.filesystemWatcher = watch(this.projectDir, {
       persistent: true,
       ignoreInitial: true,
-      ignored: (p) => shouldIgnorePath(path68.relative(this.projectDir, p), this.ignoredFiles)
+      ignored: (p) => shouldIgnorePath(path69.relative(this.projectDir, p), this.ignoredFiles)
     });
     this.filesystemWatcher.on("change", (filePath) => this.handleFileChangedOnFilesystem(filePath));
     this.filesystemWatcher.on("add", (filePath) => this.handleFileChangedOnFilesystem(filePath));
@@ -357647,8 +358327,8 @@ class DevServer {
     const { file } = await this.fsKy.get("api/files/get", {
       searchParams: { file_path: ev.file_path }
     }).json();
-    const fullPath = path68.join(this.projectDir, ev.file_path);
-    const dirPath = path68.dirname(fullPath);
+    const fullPath = path69.join(this.projectDir, ev.file_path);
+    const dirPath = path69.dirname(fullPath);
     if (!fs59.existsSync(dirPath)) {
       fs59.mkdirSync(dirPath, { recursive: true });
     }
@@ -357660,14 +358340,14 @@ class DevServer {
     }
   }
   async handleFileDeletedEventFromServer(ev) {
-    const fullPath = path68.join(this.projectDir, ev.file_path);
+    const fullPath = path69.join(this.projectDir, ev.file_path);
     if (fs59.existsSync(fullPath)) {
       debug12(`Deleting file ${ev.file_path} from filesystem`);
       fs59.unlinkSync(fullPath);
     }
   }
   async handleFileChangedOnFilesystem(absoluteFilePath) {
-    const relativeFilePath = path68.relative(this.projectDir, absoluteFilePath);
+    const relativeFilePath = path69.relative(this.projectDir, absoluteFilePath);
     if (relativeFilePath.includes("manual-edits.json"))
       return;
     if (shouldIgnorePath(relativeFilePath, this.ignoredFiles))
@@ -357683,14 +358363,14 @@ class DevServer {
     await this.checkAndUploadNewNodeModules(absoluteFilePath);
   }
   async checkAndUploadNewNodeModules(filePath) {
-    const ext = path68.extname(filePath).toLowerCase();
+    const ext = path69.extname(filePath).toLowerCase();
     const isSourceFile = [".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(ext);
     if (!isSourceFile)
       return;
     try {
       const nodeModuleFiles = getAllNodeModuleFilePaths(filePath, this.projectDir);
       const newFiles = nodeModuleFiles.filter((file) => {
-        const relativePath = path68.relative(this.projectDir, file);
+        const relativePath = path69.relative(this.projectDir, file);
         return !this.uploadedNodeModules.has(relativePath);
       });
       if (newFiles.length === 0)
@@ -357703,7 +358383,7 @@ class DevServer {
     }
   }
   async handleFileRemovedFromFilesystem(absoluteFilePath) {
-    const relativeFilePath = path68.relative(this.projectDir, absoluteFilePath);
+    const relativeFilePath = path69.relative(this.projectDir, absoluteFilePath);
     if (shouldIgnorePath(relativeFilePath, this.ignoredFiles))
       return;
     this.autorouterPhaseReached = false;
@@ -357742,8 +358422,8 @@ class DevServer {
     debug12(`Successfully deleted file ${relativeFilePath} from server`);
   }
   async handleFileRename(oldPath, newPath) {
-    const oldRelativePath = path68.relative(this.projectDir, oldPath);
-    const newRelativePath = path68.relative(this.projectDir, newPath);
+    const oldRelativePath = path69.relative(this.projectDir, oldPath);
+    const newRelativePath = path69.relative(this.projectDir, newPath);
     if (shouldIgnorePath(oldRelativePath, this.ignoredFiles) || shouldIgnorePath(newRelativePath, this.ignoredFiles))
       return;
     await this.handleFileRemovedFromFilesystem(oldPath);
@@ -357761,7 +358441,7 @@ class DevServer {
     });
     const filePaths = getPackageFilePaths(this.projectDir, this.ignoredFiles);
     for (const filePath of filePaths) {
-      const relativeFilePath = path68.relative(this.projectDir, filePath);
+      const relativeFilePath = path69.relative(this.projectDir, filePath);
       const filePayload = this.createFileUploadPayload(filePath, relativeFilePath);
       await this.postFileUpsert({
         filePath: relativeFilePath,
@@ -357793,7 +358473,7 @@ class DevServer {
   }
   async uploadNodeModuleFiles(files) {
     for (const nodeModuleFile of files) {
-      const relativeFilePath = path68.relative(this.projectDir, nodeModuleFile);
+      const relativeFilePath = path69.relative(this.projectDir, nodeModuleFile);
       this.uploadedNodeModules.add(relativeFilePath);
       const filePayload = this.createFileUploadPayload(nodeModuleFile, relativeFilePath);
       await this.postFileUpsert({
@@ -357832,7 +358512,7 @@ class DevServer {
   getInitialNodeModuleDependencyEntryFiles() {
     const entryFiles = [this.componentFilePath];
     for (const configFileName of CONFIG_MODULE_FILENAMES2) {
-      const configPath = path68.join(this.projectDir, configFileName);
+      const configPath = path69.join(this.projectDir, configFileName);
       if (fs59.existsSync(configPath)) {
         entryFiles.push(configPath);
       }
@@ -357848,7 +358528,7 @@ class DevServer {
     formData.set("file_path", filePath);
     formData.set("initiator", initiator);
     const binaryBytes = Uint8Array.from(binaryContent);
-    formData.set("binary_file", new Blob([binaryBytes]), path68.basename(filePath));
+    formData.set("binary_file", new Blob([binaryBytes]), path69.basename(filePath));
     const response = await fetch(`http://localhost:${this.port}/api/files/upsert-multipart`, {
       method: "POST",
       body: formData
@@ -357888,7 +358568,7 @@ class DevServer {
     await this.filesystemWatcher?.close();
   }
   createFileUploadPayload(absoluteFilePath, relativeFilePath) {
-    const ext = path68.extname(relativeFilePath).toLowerCase();
+    const ext = path69.extname(relativeFilePath).toLowerCase();
     if (BINARY_FILE_EXTENSIONS2.has(ext)) {
       const fileBuffer = fs59.readFileSync(absoluteFilePath);
       return { binary_content: fileBuffer };
@@ -357934,7 +358614,7 @@ var isPortAvailable = (port) => {
   });
 };
 var warnIfTsconfigMissingTscircuitType = (projectDir) => {
-  const tsconfigPath = path69.join(projectDir, "tsconfig.json");
+  const tsconfigPath = path70.join(projectDir, "tsconfig.json");
   if (!fs60.existsSync(tsconfigPath)) {
     return;
   }
@@ -357974,7 +358654,7 @@ var registerDev = (program) => {
 
   ${kleur_default.green(`@tscircuit/cli@${getVersion()}`)} ${kleur_default.gray("ready in")} ${kleur_default.white(`${Math.round(timeToStart)}ms`)}`);
     console.log(`
-  ${kleur_default.bold("➜ Local:")}   ${kleur_default.underline(kleur_default.cyan(`http://localhost:${port}`))}${server.componentFilePath ? kleur_default.underline(kleur_default.cyan(`/#file=${encodeURIComponent(path69.relative(process.cwd(), server.componentFilePath).replaceAll("\\", "/"))}`)) : ""}
+  ${kleur_default.bold("➜ Local:")}   ${kleur_default.underline(kleur_default.cyan(`http://localhost:${port}`))}${server.componentFilePath ? kleur_default.underline(kleur_default.cyan(`/#file=${encodeURIComponent(path70.relative(process.cwd(), server.componentFilePath).replaceAll("\\", "/"))}`)) : ""}
 
 `);
     console.log(kleur_default.gray(`Watching ${kleur_default.underline(server.projectDir.split("/").slice(-2).join("/"))} for changes...`));
@@ -358007,13 +358687,13 @@ var checkLoggedIn = () => {
 import { spawnSync as spawnSync2 } from "node:child_process";
 import fs61 from "node:fs";
 import os7 from "node:os";
-import path70 from "node:path";
+import path71 from "node:path";
 var hasBunInstalled = () => {
   const result = spawnSync2("bun", ["--version"], { stdio: "ignore" });
   return result.status === 0;
 };
 var createTempProject = (tempDir) => {
-  const packageJsonPath = path70.join(tempDir, "package.json");
+  const packageJsonPath = path71.join(tempDir, "package.json");
   const packageJson = {
     name: "tsci-doctor-check",
     version: "0.0.0",
@@ -358033,7 +358713,7 @@ var checkGlobalNpmrcRegistry = async () => {
       details: "Bun is required to verify registry settings. Install Bun and rerun `tsci doctor`."
     };
   }
-  const tempDir = fs61.mkdtempSync(path70.join(os7.tmpdir(), "tsci-doctor-"));
+  const tempDir = fs61.mkdtempSync(path71.join(os7.tmpdir(), "tsci-doctor-"));
   try {
     createTempProject(tempDir);
     const result = spawnSync2("bun", ["install"], {
@@ -358121,7 +358801,7 @@ function getPcbXRaySettings(options) {
 
 // lib/shared/export-snippet.ts
 import fs62 from "node:fs";
-import path71 from "node:path";
+import path72 from "node:path";
 import { promisify as promisify4 } from "node:util";
 
 // node_modules/circuit-json-to-bom-csv/dist/index.js
@@ -361598,13 +362278,13 @@ var RELATIONSHIPS_XML = `<?xml version="1.0" encoding="UTF-8"?>
   <Relationship Target="/3D/3dmodel.model" Id="rel-1" Type="http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel" />
 </Relationships>
 `;
-var escapeXml3 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+var escapeXml4 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
 var formatNumber4 = (value) => {
   const normalized = Math.abs(value) < 0.0000005 ? 0 : value;
   return normalized.toFixed(6).replace(/(?:\.0+|(?<decimal>\.[0-9]*?)0+)$/, "$<decimal>");
 };
 var appendMeshObject = (output, mesh, objectId) => {
-  output.push(`    <object id="${objectId}" type="model" name="${escapeXml3(mesh.name)}" pid="1" pindex="${mesh.materialIndex}">
+  output.push(`    <object id="${objectId}" type="model" name="${escapeXml4(mesh.name)}" pid="1" pindex="${mesh.materialIndex}">
 `, `      <mesh>
 `, `        <vertices>
 `);
@@ -361632,7 +362312,7 @@ var createBambuModelSettings = (meshes, assemblyId, title) => {
 `,
     `  <object id="${assemblyId}">
 `,
-    `    <metadata key="name" value="${escapeXml3(title)}"/>
+    `    <metadata key="name" value="${escapeXml4(title)}"/>
 `,
     `    <metadata key="extruder" value="1"/>
 `
@@ -361641,7 +362321,7 @@ var createBambuModelSettings = (meshes, assemblyId, title) => {
     const objectId = index + 2;
     const extruder = mesh.materialIndex + 1;
     settings.push(`    <part id="${objectId}" subtype="normal_part">
-`, `      <metadata key="name" value="${escapeXml3(mesh.name)}"/>
+`, `      <metadata key="name" value="${escapeXml4(mesh.name)}"/>
 `, `      <metadata key="extruder" value="${extruder}"/>
 `, `      <mesh_stat face_count="${mesh.triangles.length / 3}" edges_fixed="0" degenerate_facets="0" facets_removed="0" facets_reversed="0" backwards_edges="0"/>
 `, `    </part>
@@ -361666,7 +362346,7 @@ var createThreeMf = ({
 `,
     `<model unit="millimeter" xml:lang="en-US" xmlns="http://schemas.microsoft.com/3dmanufacturing/core/2015/02">
 `,
-    `  <metadata name="Title">${escapeXml3(title)}</metadata>
+    `  <metadata name="Title">${escapeXml4(title)}</metadata>
 `,
     `  <metadata name="Designer">tscircuit</metadata>
 `,
@@ -361690,7 +362370,7 @@ var createThreeMf = ({
     appendMeshObject(model, mesh, index + 2);
   }
   const assemblyId = meshes.length + 2;
-  model.push(`    <object id="${assemblyId}" type="model" name="${escapeXml3(title)}">
+  model.push(`    <object id="${assemblyId}" type="model" name="${escapeXml4(title)}">
 `, `      <components>
 `);
   for (let objectId = 2;objectId < assemblyId; objectId += 1) {
@@ -363157,10 +363837,10 @@ var exportSnippet = async ({
     onError(`Invalid format: ${format}`);
     return onExit(1);
   }
-  const projectDir = path71.dirname(filePath);
-  const outputBaseName = path71.basename(filePath).replace(/\.[^.]+$/, "");
+  const projectDir = path72.dirname(filePath);
+  const outputBaseName = path72.basename(filePath).replace(/\.[^.]+$/, "");
   const outputFileName = `${outputBaseName}${OUTPUT_EXTENSIONS[format]}`;
-  const outputDestination = outputPath && path71.isAbsolute(outputPath) ? outputPath : path71.join(projectDir, outputPath ?? outputFileName);
+  const outputDestination = outputPath && path72.isAbsolute(outputPath) ? outputPath : path72.join(projectDir, outputPath ?? outputFileName);
   if (format === "kicad-library") {
     try {
       const result = await convertToKicadLibrary({
@@ -363254,7 +363934,7 @@ var exportSnippet = async ({
       }
       break;
     case "altium": {
-      await Promise.resolve().then(() => init_lib3());
+      await Promise.resolve().then(() => init_lib4());
       outputContent = Buffer.from(await convertCircuitJsonToAltiumZip(circuitJson, outputBaseName));
       break;
     }
@@ -363292,7 +363972,7 @@ var exportSnippet = async ({
         model3dSourcePaths: pcbConverter.getModel3dSourcePaths(),
         projectName: outputBaseName,
         fetch: platformConfig?.platformFetch ?? globalThis.fetch,
-        readFile: (modelPath) => fs62.promises.readFile(path71.resolve(projectDir, modelPath)),
+        readFile: (modelPath) => fs62.promises.readFile(path72.resolve(projectDir, modelPath)),
         onModelFile: ({ outputPath, content }) => {
           zip.file(outputPath, content);
         },
@@ -363462,11 +364142,11 @@ var getSpiceWithPaddedSim = (circuitJson, options) => {
 
 // lib/eecircuit-engine/run-simulation.ts
 import { promises as fs63, existsSync as existsSync15 } from "node:fs";
-import path72 from "node:path";
+import path73 from "node:path";
 import os8 from "node:os";
 var sim = null;
 var fetchSimulation = async () => {
-  const tempFilePath = path72.join(os8.tmpdir(), `tscircuit-eecircuit-engine-1.7.4.mjs`);
+  const tempFilePath = path73.join(os8.tmpdir(), `tscircuit-eecircuit-engine-1.7.4.mjs`);
   if (!existsSync15(tempFilePath)) {
     const url = `https://jscdn.tscircuit.com/@tscircuit/eecircuit-engine/1.7.4/dist/eecircuit-engine.mjs`;
     const response = await fetch(url);
@@ -363563,7 +364243,7 @@ var resultToCsv = (result) => {
 };
 
 // cli/export/register.ts
-import path73 from "node:path";
+import path74 from "node:path";
 import { promises as fs64 } from "node:fs";
 var registerExport = (program) => {
   addPcbXRayOptions(program.command("export")).description("Export tscircuit code to various formats").argument("<file>", "Path to the package file").option("-f, --format <format>", `Output format (${ALLOWED_EXPORT_FORMATS.join(", ")})`).option("-o, --output <path>", "Output file path").option("--layer <layer>", "PCB front layer: top or bottom").option("--disable-parts-engine", "Disable the parts engine").option("--show-courtyards", "Show courtyard outlines in PCB SVG output").action(async (file, options) => {
@@ -363589,7 +364269,7 @@ var registerExport = (program) => {
       });
       if (circuitJson) {
         const spiceString = getSpiceWithPaddedSim(circuitJson);
-        const outputSpicePath = options.output ?? path73.join(path73.dirname(file), `${path73.basename(file, path73.extname(file))}.spice.cir`);
+        const outputSpicePath = options.output ?? path74.join(path74.dirname(file), `${path74.basename(file, path74.extname(file))}.spice.cir`);
         await fs64.writeFile(outputSpicePath, spiceString);
         const { result } = await runSimulation(spiceString);
         const csvContent = resultToCsv(result);
@@ -398687,7 +399367,7 @@ function normalizeManufacturerPartNumber2(partNumber) {
 
 // lib/import/import-component-from-jlcpcb.ts
 import fs66 from "node:fs/promises";
-import path75 from "node:path";
+import path76 from "node:path";
 
 // lib/import/fetch-datasheet-pin-attributes.ts
 import { commonComponentProps as commonComponentProps2 } from "@tscircuit/props";
@@ -398752,7 +399432,7 @@ ${indentation}{...${propsName}}`);
 
 // lib/import/download-cad-model-assets.ts
 import fs65 from "node:fs/promises";
-import path74 from "node:path";
+import path75 from "node:path";
 var downloadCadModelAssets = async ({
   cadComponent,
   componentDir,
@@ -398764,7 +399444,7 @@ var downloadCadModelAssets = async ({
   if (cadComponent?.model_step_url) {
     const stepFileName = `${componentName}.step`;
     const stepResp = await platformFetch(cadComponent.model_step_url);
-    await fs65.writeFile(path74.join(componentDir, stepFileName), Buffer.from(await stepResp.arrayBuffer()));
+    await fs65.writeFile(path75.join(componentDir, stepFileName), Buffer.from(await stepResp.arrayBuffer()));
     tsx = `import stepPath from "./${stepFileName}"
 ` + tsx;
     tsx = tsx.replace(`"${cadComponent.model_step_url}"`, "stepPath");
@@ -398772,7 +399452,7 @@ var downloadCadModelAssets = async ({
   if (cadComponent?.model_obj_url) {
     const objFileName = `${componentName}.obj`;
     const objResp = await platformFetch(cadComponent.model_obj_url);
-    await fs65.writeFile(path74.join(componentDir, objFileName), Buffer.from(await objResp.arrayBuffer()));
+    await fs65.writeFile(path75.join(componentDir, objFileName), Buffer.from(await objResp.arrayBuffer()));
     tsx = `import objPath from "./${objFileName}"
 ` + tsx;
     tsx = tsx.replace(`"${cadComponent.model_obj_url}"`, "objPath");
@@ -398993,7 +399673,7 @@ var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cw
       stepUrl: cadComponent.model_step_url ? JSON.stringify(cadComponent.model_step_url) : undefined
     }, cadComponent);
   }
-  const componentDir = options.download ? path75.join(projectDir, "imports", componentName) : path75.join(projectDir, "imports");
+  const componentDir = options.download ? path76.join(projectDir, "imports", componentName) : path76.join(projectDir, "imports");
   await fs66.mkdir(componentDir, { recursive: true });
   if (options.download) {
     tsx = await downloadCadModelAssets({
@@ -399003,7 +399683,7 @@ var importComponentFromJlcpcb = async (jlcpcbPartNumber, projectDir = process.cw
       tsx
     });
   }
-  const filePath = path75.join(componentDir, `${componentName}.tsx`);
+  const filePath = path76.join(componentDir, `${componentName}.tsx`);
   await fs66.writeFile(filePath, tsx);
   return { filePath, footprintConversion };
 };
@@ -399165,12 +399845,12 @@ var registerImport = (program) => {
 
 // cli/init/register.ts
 import * as fs68 from "node:fs";
-import * as path78 from "node:path";
+import * as path79 from "node:path";
 
 // lib/shared/generate-gitignore-file.ts
-import path76 from "node:path";
+import path77 from "node:path";
 var generateGitIgnoreFile = (dir) => {
-  const gitignorePath = path76.join(dir, ".gitignore");
+  const gitignorePath = path77.join(dir, ".gitignore");
   const gitignoreContent = `# Dependencies
 node_modules/
 
@@ -399206,7 +399886,7 @@ yarn-error.log*
 
 // lib/shared/setup-tscircuit-skill.ts
 import * as fs67 from "node:fs";
-import * as path77 from "node:path";
+import * as path78 from "node:path";
 var SKILL_REPO_API_URL = "https://api.github.com/repos/tscircuit/skill/contents";
 var SKILL_INSTALL_PATHS = [
   ".claude/skills/tscircuit",
@@ -399229,7 +399909,7 @@ async function fetchFileContent(downloadUrl) {
 async function downloadDirectory(apiUrl, targetDir) {
   const contents = await fetchGitHubContents(apiUrl);
   for (const item of contents) {
-    const targetPath = path77.join(targetDir, item.name);
+    const targetPath = path78.join(targetDir, item.name);
     if (item.type === "dir") {
       fs67.mkdirSync(targetPath, { recursive: true });
       await downloadDirectory(`${apiUrl}/${item.name}`, targetPath);
@@ -399246,7 +399926,7 @@ async function downloadSkillRepo(targetDir) {
     if (item.name === ".git" || item.name === ".github") {
       continue;
     }
-    const targetPath = path77.join(targetDir, item.name);
+    const targetPath = path78.join(targetDir, item.name);
     if (item.type === "dir") {
       fs67.mkdirSync(targetPath, { recursive: true });
       await downloadDirectory(`${SKILL_REPO_API_URL}/${item.name}`, targetPath);
@@ -399257,7 +399937,7 @@ async function downloadSkillRepo(targetDir) {
   }
 }
 async function setupTscircuitSkill(projectDir, skipPrompt = false) {
-  const missingSkillPaths = SKILL_INSTALL_PATHS.filter((skillPath) => !fs67.existsSync(path77.join(projectDir, skillPath, "SKILL.md")));
+  const missingSkillPaths = SKILL_INSTALL_PATHS.filter((skillPath) => !fs67.existsSync(path78.join(projectDir, skillPath, "SKILL.md")));
   if (missingSkillPaths.length === 0) {
     console.log("TSCircuit AI skills already exist, skipping...");
     return true;
@@ -399277,7 +399957,7 @@ async function setupTscircuitSkill(projectDir, skipPrompt = false) {
   console.info("Setting up tscircuit AI skills...");
   try {
     for (const skillPath of missingSkillPaths) {
-      const targetDir = path77.join(projectDir, skillPath);
+      const targetDir = path78.join(projectDir, skillPath);
       await downloadSkillRepo(targetDir);
       console.info(`tscircuit skill installed at ${skillPath}`);
     }
@@ -399416,7 +400096,7 @@ var registerInit = (program) => {
         }
       }
     }
-    const projectDir = directory ? path78.resolve(process.cwd(), directory) : process.cwd();
+    const projectDir = directory ? path79.resolve(process.cwd(), directory) : process.cwd();
     let tsciHandle = null;
     const token = getSessionToken();
     if (token) {
@@ -399427,7 +400107,7 @@ var registerInit = (program) => {
         }
       } catch {}
     }
-    const dirName = path78.basename(projectDir);
+    const dirName = path79.basename(projectDir);
     let defaultPackageName = dirName;
     if (tsciHandle) {
       defaultPackageName = `@tsci/${tsciHandle}.${dirName}`;
@@ -399446,7 +400126,7 @@ var registerInit = (program) => {
       }
     }
     fs68.mkdirSync(projectDir, { recursive: true });
-    writeFileIfNotExists(path78.join(projectDir, "index.circuit.tsx"), `
+    writeFileIfNotExists(path79.join(projectDir, "index.circuit.tsx"), `
 export default () => (
   <board>
     <resistor resistance="1k" footprint="0402" name="R1" />
@@ -399458,7 +400138,7 @@ export default () => (
     if (saveProjectConfig(null, projectDir)) {
       console.log("Created tscircuit.config.json with schema");
     }
-    writeFileIfNotExists(path78.join(projectDir, ".npmrc"), `
+    writeFileIfNotExists(path79.join(projectDir, ".npmrc"), `
 @tsci:registry=https://npm.tscircuit.com
 `);
     console.log("Generating package.json");
@@ -399518,12 +400198,12 @@ var registerPush = (program) => {
 
 // cli/report/autorouter/register.ts
 import fs69 from "node:fs";
-import path79 from "node:path";
+import path80 from "node:path";
 var import_prompts11 = __toESM3(require_prompts3(), 1);
 var AUTOROUTER_BUG_REPORT_VIEW_URL = "https://api.tscircuit.com/autorouting/bug_reports/view?autorouting_bug_report_id=";
 var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
 var readSimpleRouteJson = (filePath) => {
-  const resolvedFilePath = path79.resolve(filePath);
+  const resolvedFilePath = path80.resolve(filePath);
   let fileContents;
   try {
     fileContents = fs69.readFileSync(resolvedFilePath, "utf8");
@@ -399601,7 +400281,7 @@ var registerReportAutorouter = (program) => {
         console.log("Report cancelled.");
         return;
       }
-      const title = options.title?.trim() || path79.basename(file, path79.extname(file));
+      const title = options.title?.trim() || path80.basename(file, path80.extname(file));
       const { bugReportUrl } = await createAutorouterBugReport({
         title,
         simpleRouteJson
@@ -399701,7 +400381,7 @@ var registerRegistryPackagesCreate = (program) => {
 
 // cli/registry/packages/update/register.ts
 import fs70 from "node:fs";
-import path80 from "node:path";
+import path81 from "node:path";
 var normalizeGithubRepo = (input) => {
   let repo = input;
   const urlMatch = /^https?:\/\/(?:www\.)?github\.com\/([^?#]+)(?:[?#].*)?$/i.exec(input);
@@ -399714,7 +400394,7 @@ var normalizeGithubRepo = (input) => {
   return repo;
 };
 var getCurrentDirectoryPackageName = () => {
-  const packageJsonPath = path80.join(process.cwd(), "package.json");
+  const packageJsonPath = path81.join(process.cwd(), "package.json");
   if (!fs70.existsSync(packageJsonPath))
     return;
   try {
@@ -401643,20 +402323,20 @@ var registerSearch = (program) => {
 
 // lib/shared/setup-github-actions.ts
 import fs71 from "node:fs";
-import path81 from "node:path";
+import path82 from "node:path";
 var setupGithubActions = (projectDir = process.cwd()) => {
   const findGitRoot = (startDir) => {
-    let dir = path81.resolve(startDir);
-    while (dir !== path81.parse(dir).root) {
-      if (fs71.existsSync(path81.join(dir, ".git"))) {
+    let dir = path82.resolve(startDir);
+    while (dir !== path82.parse(dir).root) {
+      if (fs71.existsSync(path82.join(dir, ".git"))) {
         return dir;
       }
-      dir = path81.dirname(dir);
+      dir = path82.dirname(dir);
     }
     return null;
   };
   const gitRoot = findGitRoot(projectDir) ?? projectDir;
-  const workflowsDir = path81.join(gitRoot, ".github", "workflows");
+  const workflowsDir = path82.join(gitRoot, ".github", "workflows");
   fs71.mkdirSync(workflowsDir, { recursive: true });
   const buildWorkflow = `name: tscircuit Build
 
@@ -401696,8 +402376,8 @@ jobs:
       - run: bun install
       - run: bunx tsci snapshot
 `;
-  writeFileIfNotExists(path81.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
-  writeFileIfNotExists(path81.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
+  writeFileIfNotExists(path82.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
+  writeFileIfNotExists(path82.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
 };
 
 // cli/setup/register.ts
@@ -401814,21 +402494,21 @@ var registerSimulate = (program) => {
 
 // lib/shared/snapshot-project.ts
 import fs75 from "node:fs";
-import path84 from "node:path";
+import path85 from "node:path";
 
 // cli/snapshot/worker-pool.ts
 import fs72 from "node:fs";
-import path82 from "node:path";
+import path83 from "node:path";
 var getWorkerEntrypointPath2 = () => {
-  const tsPath = path82.join(import.meta.dir, "snapshot.worker.ts");
+  const tsPath = path83.join(import.meta.dir, "snapshot.worker.ts");
   if (fs72.existsSync(tsPath)) {
     return tsPath;
   }
-  const jsBundledPath = path82.join(import.meta.dir, "snapshot", "snapshot.worker.js");
+  const jsBundledPath = path83.join(import.meta.dir, "snapshot", "snapshot.worker.js");
   if (fs72.existsSync(jsBundledPath)) {
     return jsBundledPath;
   }
-  return path82.join(import.meta.dir, "snapshot.worker.js");
+  return path83.join(import.meta.dir, "snapshot.worker.js");
 };
 var snapshotFilesWithWorkerPool = async (options) => {
   const cancellationError = new Error("Snapshot cancelled due to file failure");
@@ -401899,7 +402579,7 @@ var snapshotFilesWithWorkerPool = async (options) => {
 
 // lib/shared/process-snapshot-file.ts
 import fs74 from "node:fs";
-import path83 from "node:path";
+import path84 from "node:path";
 import { convertCircuitJsonToStackedSchematicSheetsSvg as convertCircuitJsonToStackedSchematicSheetsSvg2 } from "circuit-to-svg";
 
 // lib/shared/compare-images.ts
@@ -401949,7 +402629,7 @@ var processSnapshotFile = async ({
   cameraPreset,
   pcbLayer
 }) => {
-  const relativeFilePath = path83.relative(projectDir, file);
+  const relativeFilePath = path84.relative(projectDir, file);
   const successPaths = [];
   const warningMessages = [];
   const mismatches = [];
@@ -402045,11 +402725,11 @@ var processSnapshotFile = async ({
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       if (errorMessage.includes("No pcb_board found in circuit JSON")) {
-        const fileDir = path83.dirname(file);
-        const relativeDir = path83.relative(projectDir, fileDir);
-        const snapDir = snapshotsDirName ? path83.join(projectDir, snapshotsDirName, relativeDir) : path83.join(fileDir, "__snapshots__");
-        const base = path83.basename(file).replace(/\.[^.]+$/, "");
-        const snap3dPath = path83.join(snapDir, `${base}-3d.snap.png`);
+        const fileDir = path84.dirname(file);
+        const relativeDir = path84.relative(projectDir, fileDir);
+        const snapDir = snapshotsDirName ? path84.join(projectDir, snapshotsDirName, relativeDir) : path84.join(fileDir, "__snapshots__");
+        const base = path84.basename(file).replace(/\.[^.]+$/, "");
+        const snap3dPath = path84.join(snapDir, `${base}-3d.snap.png`);
         const existing3dSnapshot = fs74.existsSync(snap3dPath);
         if (existing3dSnapshot) {
           return {
@@ -402061,7 +402741,7 @@ var processSnapshotFile = async ({
             errorMessage: kleur_default.red(`
 ❌ Failed to generate 3D snapshot for ${relativeFilePath}:
 `) + kleur_default.red(`   No pcb_board found in circuit JSON
-`) + kleur_default.red(`   Existing snapshot: ${path83.relative(projectDir, snap3dPath)}
+`) + kleur_default.red(`   Existing snapshot: ${path84.relative(projectDir, snap3dPath)}
 `)
           };
         }
@@ -402082,9 +402762,9 @@ var processSnapshotFile = async ({
       }
     }
   }
-  const snapDir = snapshotsDirName ? path83.join(projectDir, snapshotsDirName, path83.relative(projectDir, path83.dirname(file))) : path83.join(path83.dirname(file), "__snapshots__");
+  const snapDir = snapshotsDirName ? path84.join(projectDir, snapshotsDirName, path84.relative(projectDir, path84.dirname(file))) : path84.join(path84.dirname(file), "__snapshots__");
   fs74.mkdirSync(snapDir, { recursive: true });
-  const base = path83.basename(file).replace(/\.[^.]+$/, "");
+  const base = path84.basename(file).replace(/\.[^.]+$/, "");
   const snapshots = [];
   if (!simulationOnly && (pcbOnly || !schematicOnly)) {
     let pcbSnapshotType = "pcb";
@@ -402125,13 +402805,13 @@ var processSnapshotFile = async ({
   for (const snapshot of snapshots) {
     const { type } = snapshot;
     const is3d = type === "3d";
-    const snapPath = path83.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
+    const snapPath = path84.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
     const existing = fs74.existsSync(snapPath);
     const newContentBuffer = snapshot.isBinary ? snapshot.content : Buffer.from(snapshot.content, "utf8");
     const newContentForFile = snapshot.content;
     if (!existing) {
       fs74.writeFileSync(snapPath, newContentForFile);
-      successPaths.push(path83.relative(projectDir, snapPath));
+      successPaths.push(path84.relative(projectDir, snapPath));
       didUpdate = true;
       continue;
     }
@@ -402149,16 +402829,16 @@ var processSnapshotFile = async ({
     }
     if (update) {
       if (!forceUpdate && equal) {
-        successPaths.push(path83.relative(projectDir, snapPath));
+        successPaths.push(path84.relative(projectDir, snapPath));
       } else {
         fs74.writeFileSync(snapPath, newContentForFile);
-        successPaths.push(path83.relative(projectDir, snapPath));
+        successPaths.push(path84.relative(projectDir, snapPath));
         didUpdate = true;
       }
     } else if (!equal) {
       mismatches.push(diffPath ? `${snapPath} (diff: ${diffPath})` : snapPath);
     } else {
-      successPaths.push(path83.relative(projectDir, snapPath));
+      successPaths.push(path84.relative(projectDir, snapPath));
     }
   }
   return {
@@ -402203,7 +402883,7 @@ var snapshotProject = async ({
     ...DEFAULT_IGNORED_PATTERNS,
     ...ignored.map(normalizeIgnorePattern)
   ];
-  const resolvedPaths = filePaths.map((f) => path84.resolve(projectDir, f));
+  const resolvedPaths = filePaths.map((f) => path85.resolve(projectDir, f));
   const explicitDirectoryTarget = resolvedPaths.find((resolvedPath) => {
     if (!fs75.existsSync(resolvedPath)) {
       return false;
@@ -402217,7 +402897,7 @@ var snapshotProject = async ({
   });
   if (boardFiles.length === 0) {
     if (explicitDirectoryTarget) {
-      const relativeDirectory = path84.relative(projectDir, explicitDirectoryTarget) || ".";
+      const relativeDirectory = path85.relative(projectDir, explicitDirectoryTarget) || ".";
       const runtimeIncludeBoardFilePatterns = projectConfig?.includeBoardFiles?.filter((pattern) => pattern.trim()) ?? [];
       const includeBoardFilePatterns = runtimeIncludeBoardFilePatterns.length > 0 ? runtimeIncludeBoardFilePatterns : getBoardFilePatterns(projectDir);
       const patternSourceMessage = hasConfiguredIncludeBoardFiles(projectConfig) ? "Searched using tscircuit.config.json includeBoardFiles" : "Searched using default includeBoardFiles";
@@ -402388,7 +403068,7 @@ var registerSnapshot = (program) => {
 };
 
 // cli/transpile/register.ts
-import path85 from "node:path";
+import path86 from "node:path";
 var registerTranspile = (program) => {
   program.command("transpile").description("Transpile TypeScript/TSX to JavaScript (ESM, CommonJS, and type declarations)").argument("[file]", "Path to the entry file").action(async (file) => {
     try {
@@ -402396,7 +403076,7 @@ var registerTranspile = (program) => {
         fileOrDir: file,
         includeBoardFiles: false
       });
-      const distDir = path85.join(projectDir, "dist");
+      const distDir = path86.join(projectDir, "dist");
       validateMainInDist(projectDir, distDir);
       console.log("Transpiling entry file...");
       const entryFile = mainEntrypoint || circuitFiles[0];
@@ -402434,12 +403114,12 @@ function registerUpgradeCommand(program) {
 }
 
 // lib/shared/update-package.ts
-import * as path86 from "node:path";
+import * as path87 from "node:path";
 import * as fs76 from "node:fs";
 async function updatePackage(packageSpec, projectDir = process.cwd()) {
   const packageManager = getPackageManager();
   if (!packageSpec) {
-    const pkgJsonPath = path86.join(projectDir, "package.json");
+    const pkgJsonPath = path87.join(projectDir, "package.json");
     if (!fs76.existsSync(pkgJsonPath)) {
       console.log(kleur_default.yellow("No package.json found. Cannot update all packages."));
       return;
@@ -402525,6 +403205,7 @@ registerReport(program2);
 registerReportAutorouter(program2);
 registerCheck(program2);
 registerCheckNetlist(program2);
+registerCheckPcbStyle(program2);
 registerCheckPinSpecification(program2);
 registerCheckPlacement(program2);
 registerCheckRoutingDifficulty(program2);