@tscircuit/cli 0.1.1289 → 0.1.1291

package/dist/cli/main.js

@@ -60611,6 +60611,616 @@ var init_dist_VYXUNJDT = __esm(() => {
   ];
 });
 
+// node_modules/circuit-json-trace-length-analysis/lib/analyze-circuit-json-trace-length.ts
+class Trace {
+  id;
+  label;
+  connectionType;
+  connectionTarget;
+  connectionTargetPosition;
+  connectedPins;
+  pinPositions;
+  requirements;
+  points;
+  lengthMm;
+  straightLineDistanceMm;
+  sourceTraceId;
+  displayName;
+  constructor(model) {
+    this.id = model.id;
+    this.label = model.label;
+    this.connectionType = model.connectionType;
+    this.connectionTarget = model.connectionTarget;
+    this.connectionTargetPosition = model.connectionTargetPosition;
+    this.connectedPins = model.connectedPins;
+    this.pinPositions = model.pinPositions;
+    this.requirements = model.requirements;
+    this.points = model.points;
+    this.lengthMm = model.lengthMm;
+    this.straightLineDistanceMm = model.straightLineDistanceMm;
+    this.sourceTraceId = model.sourceTraceId;
+    this.displayName = model.displayName;
+  }
+  toString() {
+    const lines = [
+      `<Trace id="${escapeXml(this.id)}" label="${escapeXml(this.label)}" connectionType="${escapeXml(this.connectionType)}" lengthMm="${formatNumber3(this.lengthMm)}" straightLineDistanceMm="${formatNumber3(this.straightLineDistanceMm)}">`,
+      `  <ConnectedPins>`,
+      ...this.connectedPins.map((pin) => `    <Pin ref="${escapeXml(pin.ref)}" />`),
+      `  </ConnectedPins>`,
+      `  <PinPositions>`,
+      ...this.pinPositions.map((pin) => renderPinPosition(pin, "    ")),
+      `  </PinPositions>`,
+      renderConnection(this),
+      renderRequirements(this.requirements, "  "),
+      `</Trace>`
+    ];
+    if (this.points.length > 0) {
+      lines.splice(lines.length - 1, 0, `  <Path>`, ...this.points.map((point5) => `    <Point x="${formatNumber3(point5.x)}" y="${formatNumber3(point5.y)}" layer="${escapeXml(point5.layer)}" kind="${escapeXml(point5.kind)}" />`), `  </Path>`);
+    }
+    return lines.join(`
+`);
+  }
+}
+
+class TraceLengthAnalysis {
+  requestedTarget;
+  resolvedTarget;
+  targetKind;
+  totalLengthMm;
+  totalStraightLineDistanceMm;
+  traceCount;
+  #traces;
+  constructor(args) {
+    this.requestedTarget = args.requestedTarget;
+    this.resolvedTarget = args.resolvedTarget;
+    this.targetKind = args.targetKind;
+    this.#traces = [...args.traces];
+    this.totalLengthMm = this.#traces.reduce((sum, trace) => sum + trace.lengthMm, 0);
+    this.totalStraightLineDistanceMm = this.#traces.reduce((sum, trace) => sum + trace.straightLineDistanceMm, 0);
+    this.traceCount = this.#traces.length;
+  }
+  listTraces() {
+    return [...this.#traces];
+  }
+  toString() {
+    const lines = [
+      `<TraceLengthAnalysis requestedTarget="${escapeXml(this.requestedTarget)}" resolvedTarget="${escapeXml(this.resolvedTarget)}" targetKind="${escapeXml(this.targetKind)}" traceCount="${this.traceCount}" totalLengthMm="${formatNumber3(this.totalLengthMm)}" totalStraightLineDistanceMm="${formatNumber3(this.totalStraightLineDistanceMm)}">`,
+      ...this.#traces.flatMap((trace) => trace.toString().split(`
+`).map((line2) => `  ${line2}`)),
+      `</TraceLengthAnalysis>`
+    ];
+    return lines.join(`
+`);
+  }
+}
+function analyzeCircuitJsonTraceLength(circuitJson, options) {
+  const index = new CircuitJsonIndex(circuitJson);
+  const target = resolveTarget(index, options.targetPinOrNet);
+  const traces = target.kind === "pin" ? collectPinTraces(index, target) : collectNetTraces(index, target);
+  return new TraceLengthAnalysis({
+    requestedTarget: target.requestedTarget,
+    resolvedTarget: target.resolvedTarget,
+    targetKind: target.kind,
+    traces
+  });
+}
+
+class CircuitJsonIndex {
+  componentsById = new Map;
+  componentsByName = new Map;
+  portsById = new Map;
+  portsByComponentId = new Map;
+  netsById = new Map;
+  netsByName = new Map;
+  pcbPortsBySourcePortId = new Map;
+  pcbTracesBySourceTraceId = new Map;
+  pcbTracesByConnectionName = new Map;
+  tracesById = new Map;
+  tracesByPortId = new Map;
+  tracesByNetId = new Map;
+  constructor(circuitJson) {
+    for (const item of circuitJson) {
+      switch (item.type) {
+        case "source_component":
+          this.addComponent(item);
+          break;
+        case "source_port":
+          this.addPort(item);
+          break;
+        case "source_net":
+          this.addNet(item);
+          break;
+        case "pcb_port":
+          this.addPcbPort(item);
+          break;
+        case "pcb_trace":
+          this.addPcbTrace(item);
+          break;
+        case "source_trace":
+          this.addTrace(item);
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  getComponentByName(name) {
+    return this.lookupWithCaseFallback(this.componentsByName, name);
+  }
+  getNetByName(name) {
+    return this.lookupWithCaseFallback(this.netsByName, name);
+  }
+  getPcbPort(sourcePortId) {
+    return this.pcbPortsBySourcePortId.get(sourcePortId)?.[0];
+  }
+  getPortPosition(sourcePortId) {
+    const pcbPort = this.getPcbPort(sourcePortId);
+    if (!pcbPort || typeof pcbPort.x !== "number" || typeof pcbPort.y !== "number") {
+      return null;
+    }
+    const layers = normalizeLayers(pcbPort.layers);
+    return {
+      x: pcbPort.x,
+      y: pcbPort.y,
+      layers
+    };
+  }
+  getPortReference(sourcePortId) {
+    const port = this.portsById.get(sourcePortId);
+    if (!port) {
+      return sourcePortId;
+    }
+    const component = this.componentsById.get(port.source_component_id);
+    const componentName = component?.name ?? port.source_component_id;
+    const portName = port.name ?? String(port.pin_number ?? port.source_port_id);
+    return `${componentName}.${portName}`;
+  }
+  getPcbPathPoints(sourceTraceId) {
+    const candidates = dedupePcbTraces([
+      ...this.pcbTracesBySourceTraceId.get(sourceTraceId) ?? [],
+      ...this.pcbTracesByConnectionName.get(sourceTraceId) ?? []
+    ]);
+    const pcbTraceIds = new Set(candidates.map((trace) => trace.pcb_trace_id));
+    if (candidates.length === 0 || pcbTraceIds.size > 1) {
+      return [];
+    }
+    const routePoints = candidates.flatMap((trace) => normalizePcbTraceRoute(trace));
+    return convertPcbTraceRouteToPath(routePoints);
+  }
+  getConnectedPinsForNet(sourceNetId) {
+    const traces = this.tracesByNetId.get(sourceNetId) ?? [];
+    const sourcePortIds = new Set;
+    for (const trace of traces) {
+      for (const sourcePortId of trace.connected_source_port_ids ?? []) {
+        sourcePortIds.add(sourcePortId);
+      }
+    }
+    return [...sourcePortIds].map((sourcePortId) => this.toConnectedPin(sourcePortId));
+  }
+  toConnectedPin(sourcePortId) {
+    const position2 = this.getPortPosition(sourcePortId);
+    return {
+      ref: this.getPortReference(sourcePortId),
+      x: position2?.x ?? null,
+      y: position2?.y ?? null,
+      layers: position2?.layers ?? []
+    };
+  }
+  addComponent(component) {
+    this.componentsById.set(component.source_component_id, component);
+    const name = component.name;
+    if (!name) {
+      return;
+    }
+    this.addLookup(this.componentsByName, name, component);
+  }
+  addPort(port) {
+    this.portsById.set(port.source_port_id, port);
+    this.addLookup(this.portsByComponentId, port.source_component_id, port);
+  }
+  addNet(net) {
+    this.netsById.set(net.source_net_id, net);
+    const name = net.name;
+    if (!name) {
+      return;
+    }
+    this.addLookup(this.netsByName, name, net);
+  }
+  addPcbPort(pcbPort) {
+    this.addLookup(this.pcbPortsBySourcePortId, pcbPort.source_port_id, pcbPort);
+  }
+  addPcbTrace(pcbTrace) {
+    if (pcbTrace.source_trace_id) {
+      this.addLookup(this.pcbTracesBySourceTraceId, pcbTrace.source_trace_id, pcbTrace);
+    }
+    if (pcbTrace.connection_name) {
+      this.addLookup(this.pcbTracesByConnectionName, pcbTrace.connection_name, pcbTrace);
+    }
+  }
+  addTrace(trace) {
+    this.tracesById.set(trace.source_trace_id, trace);
+    for (const sourcePortId of trace.connected_source_port_ids ?? []) {
+      this.addLookup(this.tracesByPortId, sourcePortId, trace);
+    }
+    for (const sourceNetId of trace.connected_source_net_ids ?? []) {
+      this.addLookup(this.tracesByNetId, sourceNetId, trace);
+    }
+  }
+  addLookup(map, key, value) {
+    const existing = map.get(key) ?? [];
+    existing.push(value);
+    map.set(key, existing);
+  }
+  lookupWithCaseFallback(map, key) {
+    const exactMatch = map.get(key);
+    if (exactMatch?.length) {
+      return exactMatch;
+    }
+    const loweredKey = key.toLowerCase();
+    const fuzzyMatches = [];
+    for (const [candidateKey, values] of map.entries()) {
+      if (candidateKey.toLowerCase() === loweredKey) {
+        fuzzyMatches.push(...values);
+      }
+    }
+    return fuzzyMatches;
+  }
+}
+function resolveTarget(index, targetPinOrNet) {
+  if (targetPinOrNet.includes(".")) {
+    if (targetPinOrNet.startsWith("net.")) {
+      const netName = targetPinOrNet.slice("net.".length);
+      const net = resolveNetByName(index, netName);
+      return {
+        kind: "net",
+        requestedTarget: targetPinOrNet,
+        resolvedTarget: `net.${net.name ?? net.source_net_id}`,
+        net
+      };
+    }
+    return resolvePinTarget(index, targetPinOrNet);
+  }
+  const matchingNet = resolveOptionalNetByName(index, targetPinOrNet);
+  if (matchingNet) {
+    const resolvedTarget = `net.${matchingNet.name ?? matchingNet.source_net_id}`;
+    console.log(`inferring ${resolvedTarget}`);
+    return {
+      kind: "net",
+      requestedTarget: targetPinOrNet,
+      resolvedTarget,
+      net: matchingNet
+    };
+  }
+  const matchingPin = resolveOptionalPinByLabel(index, targetPinOrNet);
+  if (matchingPin) {
+    const resolvedTarget = index.getPortReference(matchingPin.source_port_id);
+    console.log(`inferring ${resolvedTarget}`);
+    return {
+      kind: "pin",
+      requestedTarget: targetPinOrNet,
+      resolvedTarget,
+      port: matchingPin
+    };
+  }
+  throw new Error(`Unable to resolve target "${targetPinOrNet}" to a pin or net`);
+}
+function resolvePinTarget(index, targetPinOrNet) {
+  const [componentName, ...pinParts] = targetPinOrNet.split(".");
+  const pinLabelOrNumber = pinParts.join(".");
+  if (!componentName || !pinLabelOrNumber) {
+    throw new Error(`Invalid pin target "${targetPinOrNet}"`);
+  }
+  const components = index.getComponentByName(componentName);
+  if (components.length !== 1) {
+    throw new Error(components.length === 0 ? `Unable to find component "${componentName}"` : `Component "${componentName}" is ambiguous`);
+  }
+  const component = components[0];
+  if (!component) {
+    throw new Error(`Unable to find component "${componentName}"`);
+  }
+  const ports = index.portsByComponentId.get(component.source_component_id) ?? [];
+  const matchingPorts = ports.filter((port2) => portMatchesLabel(port2, pinLabelOrNumber));
+  if (matchingPorts.length !== 1) {
+    throw new Error(matchingPorts.length === 0 ? `Unable to find pin "${pinLabelOrNumber}" on ${componentName}` : `Pin "${pinLabelOrNumber}" on ${componentName} is ambiguous`);
+  }
+  const port = matchingPorts[0];
+  if (!port) {
+    throw new Error(`Unable to find pin "${pinLabelOrNumber}" on ${componentName}`);
+  }
+  return {
+    kind: "pin",
+    requestedTarget: targetPinOrNet,
+    resolvedTarget: index.getPortReference(port.source_port_id),
+    port
+  };
+}
+function resolveOptionalPinByLabel(index, pinLabelOrNumber) {
+  const matchingPorts = [...index.portsById.values()].filter((port) => portMatchesLabel(port, pinLabelOrNumber));
+  if (matchingPorts.length !== 1) {
+    return null;
+  }
+  return matchingPorts[0] ?? null;
+}
+function resolveNetByName(index, netName) {
+  const matchingNets = index.getNetByName(netName);
+  if (matchingNets.length !== 1) {
+    throw new Error(matchingNets.length === 0 ? `Unable to find net "${netName}"` : `Net "${netName}" is ambiguous`);
+  }
+  const net = matchingNets[0];
+  if (!net) {
+    throw new Error(`Unable to find net "${netName}"`);
+  }
+  return net;
+}
+function resolveOptionalNetByName(index, netName) {
+  const matchingNets = index.getNetByName(netName);
+  if (matchingNets.length !== 1) {
+    return null;
+  }
+  return matchingNets[0] ?? null;
+}
+function collectPinTraces(index, target) {
+  const traces = index.tracesByPortId.get(target.port.source_port_id) ?? [];
+  return traces.flatMap((trace) => {
+    const netIds = trace.connected_source_net_ids ?? [];
+    if (netIds.length > 0) {
+      return netIds.map((sourceNetId) => createNetTraceModel(index, {
+        trace,
+        sourceNetId,
+        focusSourcePortId: target.port.source_port_id
+      }));
+    }
+    return [
+      createDirectTraceModel(index, {
+        trace,
+        focusSourcePortId: target.port.source_port_id
+      })
+    ];
+  }).sort(compareTraceModels).map((model) => new Trace(model));
+}
+function collectNetTraces(index, target) {
+  const traces = index.tracesByNetId.get(target.net.source_net_id) ?? [];
+  return traces.flatMap((trace) => {
+    const connectedSourcePortIds = trace.connected_source_port_ids ?? [];
+    if (connectedSourcePortIds.length === 0) {
+      return [];
+    }
+    return connectedSourcePortIds.map((focusSourcePortId) => createNetTraceModel(index, {
+      trace,
+      sourceNetId: target.net.source_net_id,
+      focusSourcePortId
+    }));
+  }).sort(compareTraceModels).map((model) => new Trace(model));
+}
+function createDirectTraceModel(index, args) {
+  const connectedSourcePortIds = args.trace.connected_source_port_ids ?? [];
+  if (connectedSourcePortIds.length === 0) {
+    throw new Error(`Trace ${args.trace.source_trace_id} has no connected ports`);
+  }
+  const orderedPortIds = prioritizeFocus(connectedSourcePortIds, args.focusSourcePortId);
+  const firstPortId = orderedPortIds[0];
+  const secondPortId = orderedPortIds[1] ?? orderedPortIds[0];
+  if (!firstPortId || !secondPortId) {
+    throw new Error(`Trace ${args.trace.source_trace_id} is missing connected ports`);
+  }
+  const firstPosition = requirePortPosition(index, firstPortId);
+  const secondPosition = requirePortPosition(index, secondPortId);
+  const secondLayer = primaryLayer(secondPosition.layers);
+  const connectedPins = orderedPortIds.map((sourcePortId) => index.toConnectedPin(sourcePortId));
+  const connectionTarget4 = index.getPortReference(secondPortId);
+  const straightLineDistanceMm = distanceBetween(firstPosition, secondPosition);
+  const points = index.getPcbPathPoints(args.trace.source_trace_id);
+  const lengthMm = points.length > 1 ? measurePathLength(points) : straightLineDistanceMm;
+  return {
+    id: args.trace.source_trace_id,
+    label: `${index.getPortReference(firstPortId)} -> ${connectionTarget4}`,
+    connectionType: "direct connection",
+    connectionTarget: connectionTarget4,
+    connectionTargetPosition: {
+      x: secondPosition.x,
+      y: secondPosition.y,
+      layer: secondLayer
+    },
+    connectedPins,
+    pinPositions: connectedPins,
+    requirements: {
+      maxLengthMm: typeof args.trace.max_length === "number" ? args.trace.max_length : null
+    },
+    points,
+    lengthMm,
+    straightLineDistanceMm,
+    sourceTraceId: args.trace.source_trace_id,
+    displayName: args.trace.display_name ?? null
+  };
+}
+function createNetTraceModel(index, args) {
+  const net = index.netsById.get(args.sourceNetId);
+  if (!net) {
+    throw new Error(`Unable to find net ${args.sourceNetId}`);
+  }
+  const focusPosition = requirePortPosition(index, args.focusSourcePortId);
+  const focusLayer = primaryLayer(focusPosition.layers);
+  const connectedPins = index.getConnectedPinsForNet(args.sourceNetId).sort((a2, b) => a2.ref.localeCompare(b.ref));
+  const hub = inferNetHub(connectedPins, focusLayer);
+  const focusPin = index.toConnectedPin(args.focusSourcePortId);
+  const points = index.getPcbPathPoints(args.trace.source_trace_id);
+  const straightLineDistanceMm = distanceBetween(focusPosition, hub);
+  const lengthMm = points.length > 1 ? measurePathLength(points) : straightLineDistanceMm;
+  return {
+    id: `${args.trace.source_trace_id}:${args.focusSourcePortId}`,
+    label: `${focusPin.ref} -> net.${net.name ?? net.source_net_id}`,
+    connectionType: "via net",
+    connectionTarget: `net.${net.name ?? net.source_net_id}`,
+    connectionTargetPosition: hub,
+    connectedPins: prioritizePin(focusPin, connectedPins),
+    pinPositions: prioritizePin(focusPin, connectedPins),
+    requirements: {
+      maxLengthMm: typeof args.trace.max_length === "number" ? args.trace.max_length : null
+    },
+    points,
+    lengthMm,
+    straightLineDistanceMm,
+    sourceTraceId: args.trace.source_trace_id,
+    displayName: args.trace.display_name ?? null
+  };
+}
+function requirePortPosition(index, sourcePortId) {
+  const position2 = index.getPortPosition(sourcePortId);
+  if (!position2) {
+    throw new Error(`Unable to analyze ${index.getPortReference(sourcePortId)} because it has no pcb_port position`);
+  }
+  return position2;
+}
+function inferNetHub(connectedPins, fallbackLayer) {
+  const positionedPins = connectedPins.filter((pin) => typeof pin.x === "number" && typeof pin.y === "number");
+  if (positionedPins.length === 0) {
+    return {
+      x: 0,
+      y: 0,
+      layer: fallbackLayer
+    };
+  }
+  const x3 = positionedPins.reduce((sum, pin) => sum + pin.x, 0) / positionedPins.length;
+  const y4 = positionedPins.reduce((sum, pin) => sum + pin.y, 0) / positionedPins.length;
+  const layerCounts = new Map;
+  for (const pin of positionedPins) {
+    const layer2 = pin.layers[0] ?? fallbackLayer;
+    layerCounts.set(layer2, (layerCounts.get(layer2) ?? 0) + 1);
+  }
+  const sortedLayers = [...layerCounts.entries()].sort((left, right) => {
+    if (right[1] !== left[1]) {
+      return right[1] - left[1];
+    }
+    return left[0].localeCompare(right[0]);
+  });
+  const layer = sortedLayers[0]?.[0] ?? fallbackLayer;
+  return { x: x3, y: y4, layer };
+}
+function measurePathLength(points) {
+  let lengthMm = 0;
+  for (let index = 1;index < points.length; index += 1) {
+    const previous = points[index - 1];
+    const current2 = points[index];
+    if (!previous || !current2) {
+      continue;
+    }
+    lengthMm += distanceBetween(previous, current2);
+  }
+  return lengthMm;
+}
+function dedupePcbTraces(pcbTraces) {
+  const seen = new Set;
+  const deduped = [];
+  for (const pcbTrace of pcbTraces) {
+    if (seen.has(pcbTrace)) {
+      continue;
+    }
+    seen.add(pcbTrace);
+    deduped.push(pcbTrace);
+  }
+  return deduped;
+}
+function normalizePcbTraceRoute(pcbTrace) {
+  if (!Array.isArray(pcbTrace.route)) {
+    return [];
+  }
+  return pcbTrace.route.filter((point5) => typeof point5.x === "number" && typeof point5.y === "number").map((point5) => ({
+    ...point5,
+    layer: typeof point5.layer === "string" && point5.layer.length > 0 ? point5.layer : typeof pcbTrace.layer === "string" && pcbTrace.layer.length > 0 ? pcbTrace.layer : "top"
+  }));
+}
+function convertPcbTraceRouteToPath(routePoints) {
+  const deduped = routePoints.filter((point5, index) => {
+    const previous = routePoints[index - 1];
+    return !previous || previous.x !== point5.x || previous.y !== point5.y || previous.layer !== point5.layer;
+  });
+  return deduped.map((point5, index) => ({
+    x: point5.x,
+    y: point5.y,
+    layer: point5.layer,
+    kind: classifyPcbTracePoint(point5, index, deduped.length)
+  }));
+}
+function classifyPcbTracePoint(point5, index, pointCount) {
+  if (point5.route_type === "via") {
+    return "via";
+  }
+  if (index === 0 || index === pointCount - 1 || point5.start_pcb_port_id || point5.end_pcb_port_id) {
+    return "endpoint";
+  }
+  return "track";
+}
+function renderPinPosition(pin, indent) {
+  if (typeof pin.x !== "number" || typeof pin.y !== "number") {
+    return `${indent}<Pin ref="${escapeXml(pin.ref)}" position="unavailable" />`;
+  }
+  const layers = pin.layers.length > 0 ? pin.layers.join(",") : "unknown";
+  return `${indent}<Pin ref="${escapeXml(pin.ref)}" x="${formatNumber3(pin.x)}" y="${formatNumber3(pin.y)}" layers="${escapeXml(layers)}" />`;
+}
+function renderConnection(trace) {
+  if (trace.connectionTargetPosition) {
+    return `  <Connection kind="${escapeXml(trace.connectionType)}" target="${escapeXml(trace.connectionTarget)}" x="${formatNumber3(trace.connectionTargetPosition.x)}" y="${formatNumber3(trace.connectionTargetPosition.y)}" layer="${escapeXml(trace.connectionTargetPosition.layer)}" />`;
+  }
+  return `  <Connection kind="${escapeXml(trace.connectionType)}" target="${escapeXml(trace.connectionTarget)}" />`;
+}
+function renderRequirements(requirements, indent) {
+  if (typeof requirements.maxLengthMm === "number") {
+    return [
+      `${indent}<TraceRequirements>`,
+      `${indent}  <MaxLengthMm>${formatNumber3(requirements.maxLengthMm)}</MaxLengthMm>`,
+      `${indent}</TraceRequirements>`
+    ].join(`
+`);
+  }
+  return `${indent}<TraceRequirements none />`;
+}
+function portMatchesLabel(port, label) {
+  const loweredLabel = label.toLowerCase();
+  const portName = port.name?.toLowerCase();
+  const pinNumber = String(port.pin_number ?? "").toLowerCase();
+  const portHints2 = (port.port_hints ?? []).map((hint) => hint.toLowerCase());
+  return portName === loweredLabel || pinNumber === loweredLabel || portHints2.includes(loweredLabel);
+}
+function prioritizeFocus(portIds, focusSourcePortId) {
+  const remainder = portIds.filter((portId) => portId !== focusSourcePortId);
+  return [focusSourcePortId, ...remainder];
+}
+function prioritizePin(focusPin, pins) {
+  const remainder = pins.filter((pin) => pin.ref !== focusPin.ref);
+  return [focusPin, ...remainder];
+}
+function compareTraceModels(left, right) {
+  return left.label.localeCompare(right.label);
+}
+function normalizeLayers(layers) {
+  if (!Array.isArray(layers)) {
+    return ["top"];
+  }
+  const normalizedLayers = layers.filter((layer) => typeof layer === "string" && layer.length > 0);
+  return normalizedLayers.length > 0 ? normalizedLayers : ["top"];
+}
+function primaryLayer(layers) {
+  return layers[0] ?? "top";
+}
+function distanceBetween(left, right) {
+  return Math.hypot(right.x - left.x, right.y - left.y);
+}
+function formatNumber3(value) {
+  return value.toFixed(2);
+}
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+
+// node_modules/circuit-json-trace-length-analysis/lib/index.ts
+var exports_lib = {};
+__export2(exports_lib, {
+  analyzeCircuitJsonTraceLength: () => analyzeCircuitJsonTraceLength,
+  TraceLengthAnalysis: () => TraceLengthAnalysis,
+  Trace: () => Trace
+});
+var init_lib = () => {};
+
 // node_modules/@edge-runtime/node-utils/dist/index.js
 var require_dist5 = __commonJS((exports2, module2) => {
   var __filename = "/home/runner/work/cli/cli/node_modules/@edge-runtime/node-utils/dist/index.js";
@@ -99964,7 +100574,7 @@ var import_perfect_cli = __toESM2(require_dist2(), 1);
 // lib/getVersion.ts
 import { createRequire as createRequire2 } from "node:module";
 // package.json
-var version = "0.1.1288";
+var version = "0.1.1290";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -99978,6 +100588,7 @@ var package_default = {
     "@biomejs/biome": "^1.9.4",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.6",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.1",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#d09c8d74f3085b29744bb0f1c9864c1154c69436",
     "@tscircuit/fake-snippets": "^0.0.182",
     "@tscircuit/file-server": "^0.0.32",
     "@tscircuit/image-utils": "^0.0.3",
@@ -109908,7 +110519,10 @@ var buildPreviewGltf = async ({
 // cli/build/build-preview-images.ts
 import fs30 from "node:fs";
 import path32 from "node:path";
-import { convertCircuitJsonToGltf as convertCircuitJsonToGltf3 } from "circuit-json-to-gltf";
+import {
+  convertCircuitJsonToGltf as convertCircuitJsonToGltf3,
+  getBestCameraPosition
+} from "circuit-json-to-gltf";
 import {
   convertCircuitJsonToPcbSvg,
   convertCircuitJsonToSchematicSvg
@@ -110015,7 +110629,7 @@ var generatePreviewAssets = async ({
       const glbBuffer = await convertCircuitJsonToGltf3(circuitJsonWithFileUrls, getCircuitJsonToGltfOptions({ format: "glb" }));
       console.log(`${prefix}Rendering GLB to PNG buffer...`);
       const glbArrayBuffer = await normalizeToArrayBuffer(glbBuffer);
-      const pngBuffer = await renderGLTFToPNGBufferFromGLBBuffer(glbArrayBuffer);
+      const pngBuffer = await renderGLTFToPNGBufferFromGLBBuffer(glbArrayBuffer, getBestCameraPosition(circuitJson));
       fs30.writeFileSync(path32.join(outputDir, "3d.png"), Buffer.from(normalizeToUint8Array2(pngBuffer)));
       console.log(`${prefix}Written 3d.png`);
     } catch (error) {
@@ -240617,607 +241231,268 @@ var registerCheckRouting = (program2) => {
   });
 };
 
-// node_modules/circuit-json-trace-length-analysis/lib/analyze-circuit-json-trace-length.ts
-class Trace {
-  id;
-  label;
-  connectionType;
-  connectionTarget;
-  connectionTargetPosition;
-  connectedPins;
-  pinPositions;
-  requirements;
-  points;
-  lengthMm;
-  straightLineDistanceMm;
-  sourceTraceId;
-  displayName;
-  constructor(model) {
-    this.id = model.id;
-    this.label = model.label;
-    this.connectionType = model.connectionType;
-    this.connectionTarget = model.connectionTarget;
-    this.connectionTargetPosition = model.connectionTargetPosition;
-    this.connectedPins = model.connectedPins;
-    this.pinPositions = model.pinPositions;
-    this.requirements = model.requirements;
-    this.points = model.points;
-    this.lengthMm = model.lengthMm;
-    this.straightLineDistanceMm = model.straightLineDistanceMm;
-    this.sourceTraceId = model.sourceTraceId;
-    this.displayName = model.displayName;
-  }
-  toString() {
-    const lines = [
-      `<Trace id="${escapeXml(this.id)}" label="${escapeXml(this.label)}" connectionType="${escapeXml(this.connectionType)}" lengthMm="${formatNumber3(this.lengthMm)}" straightLineDistanceMm="${formatNumber3(this.straightLineDistanceMm)}">`,
-      `  <ConnectedPins>`,
-      ...this.connectedPins.map((pin) => `    <Pin ref="${escapeXml(pin.ref)}" />`),
-      `  </ConnectedPins>`,
-      `  <PinPositions>`,
-      ...this.pinPositions.map((pin) => renderPinPosition(pin, "    ")),
-      `  </PinPositions>`,
-      renderConnection(this),
-      renderRequirements(this.requirements, "  "),
-      `</Trace>`
-    ];
-    if (this.points.length > 0) {
-      lines.splice(lines.length - 1, 0, `  <Path>`, ...this.points.map((point5) => `    <Point x="${formatNumber3(point5.x)}" y="${formatNumber3(point5.y)}" layer="${escapeXml(point5.layer)}" kind="${escapeXml(point5.kind)}" />`), `  </Path>`);
-    }
-    return lines.join(`
-`);
-  }
-}
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyze-schematic-placement.ts
+import { cju as cju7 } from "@tscircuit/circuit-json-util";
 
-class TraceLengthAnalysis {
-  requestedTarget;
-  resolvedTarget;
-  targetKind;
-  totalLengthMm;
-  totalStraightLineDistanceMm;
-  traceCount;
-  #traces;
-  constructor(args) {
-    this.requestedTarget = args.requestedTarget;
-    this.resolvedTarget = args.resolvedTarget;
-    this.targetKind = args.targetKind;
-    this.#traces = [...args.traces];
-    this.totalLengthMm = this.#traces.reduce((sum, trace) => sum + trace.lengthMm, 0);
-    this.totalStraightLineDistanceMm = this.#traces.reduce((sum, trace) => sum + trace.straightLineDistanceMm, 0);
-    this.traceCount = this.#traces.length;
-  }
-  listTraces() {
-    return [...this.#traces];
-  }
-  toString() {
-    const lines = [
-      `<TraceLengthAnalysis requestedTarget="${escapeXml(this.requestedTarget)}" resolvedTarget="${escapeXml(this.resolvedTarget)}" targetKind="${escapeXml(this.targetKind)}" traceCount="${this.traceCount}" totalLengthMm="${formatNumber3(this.totalLengthMm)}" totalStraightLineDistanceMm="${formatNumber3(this.totalStraightLineDistanceMm)}">`,
-      ...this.#traces.flatMap((trace) => trace.toString().split(`
-`).map((line2) => `  ${line2}`)),
-      `</TraceLengthAnalysis>`
-    ];
-    return lines.join(`
-`);
-  }
-}
-function analyzeCircuitJsonTraceLength(circuitJson, options) {
-  const index = new CircuitJsonIndex(circuitJson);
-  const target = resolveTarget(index, options.targetPinOrNet);
-  const traces = target.kind === "pin" ? collectPinTraces(index, target) : collectNetTraces(index, target);
-  return new TraceLengthAnalysis({
-    requestedTarget: target.requestedTarget,
-    resolvedTarget: target.resolvedTarget,
-    targetKind: target.kind,
-    traces
-  });
-}
-
-class CircuitJsonIndex {
-  componentsById = new Map;
-  componentsByName = new Map;
-  portsById = new Map;
-  portsByComponentId = new Map;
-  netsById = new Map;
-  netsByName = new Map;
-  pcbPortsBySourcePortId = new Map;
-  pcbTracesBySourceTraceId = new Map;
-  pcbTracesByConnectionName = new Map;
-  tracesById = new Map;
-  tracesByPortId = new Map;
-  tracesByNetId = new Map;
-  constructor(circuitJson) {
-    for (const item of circuitJson) {
-      switch (item.type) {
-        case "source_component":
-          this.addComponent(item);
-          break;
-        case "source_port":
-          this.addPort(item);
-          break;
-        case "source_net":
-          this.addNet(item);
-          break;
-        case "pcb_port":
-          this.addPcbPort(item);
-          break;
-        case "pcb_trace":
-          this.addPcbTrace(item);
-          break;
-        case "source_trace":
-          this.addTrace(item);
-          break;
-        default:
-          break;
-      }
-    }
-  }
-  getComponentByName(name) {
-    return this.lookupWithCaseFallback(this.componentsByName, name);
-  }
-  getNetByName(name) {
-    return this.lookupWithCaseFallback(this.netsByName, name);
-  }
-  getPcbPort(sourcePortId) {
-    return this.pcbPortsBySourcePortId.get(sourcePortId)?.[0];
-  }
-  getPortPosition(sourcePortId) {
-    const pcbPort = this.getPcbPort(sourcePortId);
-    if (!pcbPort || typeof pcbPort.x !== "number" || typeof pcbPort.y !== "number") {
-      return null;
-    }
-    const layers = normalizeLayers(pcbPort.layers);
-    return {
-      x: pcbPort.x,
-      y: pcbPort.y,
-      layers
-    };
-  }
-  getPortReference(sourcePortId) {
-    const port = this.portsById.get(sourcePortId);
-    if (!port) {
-      return sourcePortId;
-    }
-    const component = this.componentsById.get(port.source_component_id);
-    const componentName = component?.name ?? port.source_component_id;
-    const portName = port.name ?? String(port.pin_number ?? port.source_port_id);
-    return `${componentName}.${portName}`;
-  }
-  getPcbPathPoints(sourceTraceId) {
-    const candidates = dedupePcbTraces([
-      ...this.pcbTracesBySourceTraceId.get(sourceTraceId) ?? [],
-      ...this.pcbTracesByConnectionName.get(sourceTraceId) ?? []
-    ]);
-    const pcbTraceIds = new Set(candidates.map((trace) => trace.pcb_trace_id));
-    if (candidates.length === 0 || pcbTraceIds.size > 1) {
-      return [];
-    }
-    const routePoints = candidates.flatMap((trace) => normalizePcbTraceRoute(trace));
-    return convertPcbTraceRouteToPath(routePoints);
-  }
-  getConnectedPinsForNet(sourceNetId) {
-    const traces = this.tracesByNetId.get(sourceNetId) ?? [];
-    const sourcePortIds = new Set;
-    for (const trace of traces) {
-      for (const sourcePortId of trace.connected_source_port_ids ?? []) {
-        sourcePortIds.add(sourcePortId);
-      }
-    }
-    return [...sourcePortIds].map((sourcePortId) => this.toConnectedPin(sourcePortId));
-  }
-  toConnectedPin(sourcePortId) {
-    const position2 = this.getPortPosition(sourcePortId);
-    return {
-      ref: this.getPortReference(sourcePortId),
-      x: position2?.x ?? null,
-      y: position2?.y ?? null,
-      layers: position2?.layers ?? []
-    };
-  }
-  addComponent(component) {
-    this.componentsById.set(component.source_component_id, component);
-    const name = component.name;
-    if (!name) {
-      return;
-    }
-    this.addLookup(this.componentsByName, name, component);
-  }
-  addPort(port) {
-    this.portsById.set(port.source_port_id, port);
-    this.addLookup(this.portsByComponentId, port.source_component_id, port);
-  }
-  addNet(net) {
-    this.netsById.set(net.source_net_id, net);
-    const name = net.name;
-    if (!name) {
-      return;
-    }
-    this.addLookup(this.netsByName, name, net);
-  }
-  addPcbPort(pcbPort) {
-    this.addLookup(this.pcbPortsBySourcePortId, pcbPort.source_port_id, pcbPort);
-  }
-  addPcbTrace(pcbTrace) {
-    if (pcbTrace.source_trace_id) {
-      this.addLookup(this.pcbTracesBySourceTraceId, pcbTrace.source_trace_id, pcbTrace);
-    }
-    if (pcbTrace.connection_name) {
-      this.addLookup(this.pcbTracesByConnectionName, pcbTrace.connection_name, pcbTrace);
-    }
-  }
-  addTrace(trace) {
-    this.tracesById.set(trace.source_trace_id, trace);
-    for (const sourcePortId of trace.connected_source_port_ids ?? []) {
-      this.addLookup(this.tracesByPortId, sourcePortId, trace);
-    }
-    for (const sourceNetId of trace.connected_source_net_ids ?? []) {
-      this.addLookup(this.tracesByNetId, sourceNetId, trace);
-    }
-  }
-  addLookup(map, key, value) {
-    const existing = map.get(key) ?? [];
-    existing.push(value);
-    map.set(key, existing);
-  }
-  lookupWithCaseFallback(map, key) {
-    const exactMatch = map.get(key);
-    if (exactMatch?.length) {
-      return exactMatch;
-    }
-    const loweredKey = key.toLowerCase();
-    const fuzzyMatches = [];
-    for (const [candidateKey, values] of map.entries()) {
-      if (candidateKey.toLowerCase() === loweredKey) {
-        fuzzyMatches.push(...values);
-      }
-    }
-    return fuzzyMatches;
-  }
-}
-function resolveTarget(index, targetPinOrNet) {
-  if (targetPinOrNet.includes(".")) {
-    if (targetPinOrNet.startsWith("net.")) {
-      const netName = targetPinOrNet.slice("net.".length);
-      const net = resolveNetByName(index, netName);
-      return {
-        kind: "net",
-        requestedTarget: targetPinOrNet,
-        resolvedTarget: `net.${net.name ?? net.source_net_id}`,
-        net
-      };
-    }
-    return resolvePinTarget(index, targetPinOrNet);
-  }
-  const matchingNet = resolveOptionalNetByName(index, targetPinOrNet);
-  if (matchingNet) {
-    const resolvedTarget = `net.${matchingNet.name ?? matchingNet.source_net_id}`;
-    console.log(`inferring ${resolvedTarget}`);
-    return {
-      kind: "net",
-      requestedTarget: targetPinOrNet,
-      resolvedTarget,
-      net: matchingNet
-    };
-  }
-  const matchingPin = resolveOptionalPinByLabel(index, targetPinOrNet);
-  if (matchingPin) {
-    const resolvedTarget = index.getPortReference(matchingPin.source_port_id);
-    console.log(`inferring ${resolvedTarget}`);
-    return {
-      kind: "pin",
-      requestedTarget: targetPinOrNet,
-      resolvedTarget,
-      port: matchingPin
-    };
-  }
-  throw new Error(`Unable to resolve target "${targetPinOrNet}" to a pin or net`);
-}
-function resolvePinTarget(index, targetPinOrNet) {
-  const [componentName, ...pinParts] = targetPinOrNet.split(".");
-  const pinLabelOrNumber = pinParts.join(".");
-  if (!componentName || !pinLabelOrNumber) {
-    throw new Error(`Invalid pin target "${targetPinOrNet}"`);
-  }
-  const components = index.getComponentByName(componentName);
-  if (components.length !== 1) {
-    throw new Error(components.length === 0 ? `Unable to find component "${componentName}"` : `Component "${componentName}" is ambiguous`);
-  }
-  const component = components[0];
-  if (!component) {
-    throw new Error(`Unable to find component "${componentName}"`);
-  }
-  const ports = index.portsByComponentId.get(component.source_component_id) ?? [];
-  const matchingPorts = ports.filter((port2) => portMatchesLabel(port2, pinLabelOrNumber));
-  if (matchingPorts.length !== 1) {
-    throw new Error(matchingPorts.length === 0 ? `Unable to find pin "${pinLabelOrNumber}" on ${componentName}` : `Pin "${pinLabelOrNumber}" on ${componentName} is ambiguous`);
-  }
-  const port = matchingPorts[0];
-  if (!port) {
-    throw new Error(`Unable to find pin "${pinLabelOrNumber}" on ${componentName}`);
-  }
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/schematic-box-overlap.ts
+var getCenteredRectBounds = (box2) => {
+  const halfWidth = box2.width / 2;
+  const halfHeight = box2.height / 2;
   return {
-    kind: "pin",
-    requestedTarget: targetPinOrNet,
-    resolvedTarget: index.getPortReference(port.source_port_id),
-    port
-  };
-}
-function resolveOptionalPinByLabel(index, pinLabelOrNumber) {
-  const matchingPorts = [...index.portsById.values()].filter((port) => portMatchesLabel(port, pinLabelOrNumber));
-  if (matchingPorts.length !== 1) {
+    left: box2.schX - halfWidth,
+    right: box2.schX + halfWidth,
+    top: box2.schY - halfHeight,
+    bottom: box2.schY + halfHeight
+  };
+};
+var getComponentOverlap = (firstComponent, secondComponent) => {
+  const firstBounds = getCenteredRectBounds(firstComponent);
+  const secondBounds = getCenteredRectBounds(secondComponent);
+  const left = Math.max(firstBounds.left, secondBounds.left);
+  const right = Math.min(firstBounds.right, secondBounds.right);
+  const top = Math.max(firstBounds.top, secondBounds.top);
+  const bottom = Math.min(firstBounds.bottom, secondBounds.bottom);
+  const overlapWidth = right - left;
+  const overlapHeight = bottom - top;
+  if (overlapWidth <= 0 || overlapHeight <= 0) {
     return null;
   }
-  return matchingPorts[0] ?? null;
-}
-function resolveNetByName(index, netName) {
-  const matchingNets = index.getNetByName(netName);
-  if (matchingNets.length !== 1) {
-    throw new Error(matchingNets.length === 0 ? `Unable to find net "${netName}"` : `Net "${netName}" is ambiguous`);
-  }
-  const net = matchingNets[0];
-  if (!net) {
-    throw new Error(`Unable to find net "${netName}"`);
-  }
-  return net;
-}
-function resolveOptionalNetByName(index, netName) {
-  const matchingNets = index.getNetByName(netName);
-  if (matchingNets.length !== 1) {
-    return null;
-  }
-  return matchingNets[0] ?? null;
-}
-function collectPinTraces(index, target) {
-  const traces = index.tracesByPortId.get(target.port.source_port_id) ?? [];
-  return traces.flatMap((trace) => {
-    const netIds = trace.connected_source_net_ids ?? [];
-    if (netIds.length > 0) {
-      return netIds.map((sourceNetId) => createNetTraceModel(index, {
-        trace,
-        sourceNetId,
-        focusSourcePortId: target.port.source_port_id
-      }));
-    }
-    return [
-      createDirectTraceModel(index, {
-        trace,
-        focusSourcePortId: target.port.source_port_id
-      })
-    ];
-  }).sort(compareTraceModels).map((model) => new Trace(model));
-}
-function collectNetTraces(index, target) {
-  const traces = index.tracesByNetId.get(target.net.source_net_id) ?? [];
-  return traces.flatMap((trace) => {
-    const connectedSourcePortIds = trace.connected_source_port_ids ?? [];
-    if (connectedSourcePortIds.length === 0) {
-      return [];
-    }
-    return connectedSourcePortIds.map((focusSourcePortId) => createNetTraceModel(index, {
-      trace,
-      sourceNetId: target.net.source_net_id,
-      focusSourcePortId
-    }));
-  }).sort(compareTraceModels).map((model) => new Trace(model));
-}
-function createDirectTraceModel(index, args) {
-  const connectedSourcePortIds = args.trace.connected_source_port_ids ?? [];
-  if (connectedSourcePortIds.length === 0) {
-    throw new Error(`Trace ${args.trace.source_trace_id} has no connected ports`);
-  }
-  const orderedPortIds = prioritizeFocus(connectedSourcePortIds, args.focusSourcePortId);
-  const firstPortId = orderedPortIds[0];
-  const secondPortId = orderedPortIds[1] ?? orderedPortIds[0];
-  if (!firstPortId || !secondPortId) {
-    throw new Error(`Trace ${args.trace.source_trace_id} is missing connected ports`);
-  }
-  const firstPosition = requirePortPosition(index, firstPortId);
-  const secondPosition = requirePortPosition(index, secondPortId);
-  const secondLayer = primaryLayer(secondPosition.layers);
-  const connectedPins = orderedPortIds.map((sourcePortId) => index.toConnectedPin(sourcePortId));
-  const connectionTarget4 = index.getPortReference(secondPortId);
-  const straightLineDistanceMm = distanceBetween(firstPosition, secondPosition);
-  const points = index.getPcbPathPoints(args.trace.source_trace_id);
-  const lengthMm = points.length > 1 ? measurePathLength(points) : straightLineDistanceMm;
   return {
-    id: args.trace.source_trace_id,
-    label: `${index.getPortReference(firstPortId)} -> ${connectionTarget4}`,
-    connectionType: "direct connection",
-    connectionTarget: connectionTarget4,
-    connectionTargetPosition: {
-      x: secondPosition.x,
-      y: secondPosition.y,
-      layer: secondLayer
-    },
-    connectedPins,
-    pinPositions: connectedPins,
-    requirements: {
-      maxLengthMm: typeof args.trace.max_length === "number" ? args.trace.max_length : null
-    },
-    points,
-    lengthMm,
-    straightLineDistanceMm,
-    sourceTraceId: args.trace.source_trace_id,
-    displayName: args.trace.display_name ?? null
+    lineItemType: "ComponentOverlap",
+    firstComponent,
+    secondComponent,
+    overlapWidth,
+    overlapHeight,
+    correctionSuggestions: getOverlapCorrectionSuggestions({
+      firstComponent,
+      secondComponent,
+      overlapWidth,
+      overlapHeight
+    })
   };
-}
-function createNetTraceModel(index, args) {
-  const net = index.netsById.get(args.sourceNetId);
-  if (!net) {
-    throw new Error(`Unable to find net ${args.sourceNetId}`);
-  }
-  const focusPosition = requirePortPosition(index, args.focusSourcePortId);
-  const focusLayer = primaryLayer(focusPosition.layers);
-  const connectedPins = index.getConnectedPinsForNet(args.sourceNetId).sort((a2, b) => a2.ref.localeCompare(b.ref));
-  const hub = inferNetHub(connectedPins, focusLayer);
-  const focusPin = index.toConnectedPin(args.focusSourcePortId);
-  const points = index.getPcbPathPoints(args.trace.source_trace_id);
-  const straightLineDistanceMm = distanceBetween(focusPosition, hub);
-  const lengthMm = points.length > 1 ? measurePathLength(points) : straightLineDistanceMm;
-  return {
-    id: `${args.trace.source_trace_id}:${args.focusSourcePortId}`,
-    label: `${focusPin.ref} -> net.${net.name ?? net.source_net_id}`,
-    connectionType: "via net",
-    connectionTarget: `net.${net.name ?? net.source_net_id}`,
-    connectionTargetPosition: hub,
-    connectedPins: prioritizePin(focusPin, connectedPins),
-    pinPositions: prioritizePin(focusPin, connectedPins),
-    requirements: {
-      maxLengthMm: typeof args.trace.max_length === "number" ? args.trace.max_length : null
+};
+var getOverlapCorrectionSuggestions = ({
+  firstComponent,
+  secondComponent,
+  overlapWidth,
+  overlapHeight
+}) => {
+  const firstArea = firstComponent.width * firstComponent.height;
+  const secondArea = secondComponent.width * secondComponent.height;
+  const targetComponent = firstArea <= secondArea ? firstComponent : secondComponent;
+  const otherComponent = targetComponent === firstComponent ? secondComponent : firstComponent;
+  const deltaSchX = targetComponent.schX <= otherComponent.schX ? -overlapWidth : overlapWidth;
+  const deltaSchY = targetComponent.schY <= otherComponent.schY ? -overlapHeight : overlapHeight;
+  return [
+    {
+      targetComponentName: targetComponent.sourceComponentName,
+      deltaSchX,
+      deltaSchY: 0,
+      newSchX: targetComponent.schX + deltaSchX,
+      newSchY: targetComponent.schY
     },
-    points,
-    lengthMm,
-    straightLineDistanceMm,
-    sourceTraceId: args.trace.source_trace_id,
-    displayName: args.trace.display_name ?? null
-  };
-}
-function requirePortPosition(index, sourcePortId) {
-  const position2 = index.getPortPosition(sourcePortId);
-  if (!position2) {
-    throw new Error(`Unable to analyze ${index.getPortReference(sourcePortId)} because it has no pcb_port position`);
-  }
-  return position2;
-}
-function inferNetHub(connectedPins, fallbackLayer) {
-  const positionedPins = connectedPins.filter((pin) => typeof pin.x === "number" && typeof pin.y === "number");
-  if (positionedPins.length === 0) {
-    return {
-      x: 0,
-      y: 0,
-      layer: fallbackLayer
-    };
-  }
-  const x3 = positionedPins.reduce((sum, pin) => sum + pin.x, 0) / positionedPins.length;
-  const y4 = positionedPins.reduce((sum, pin) => sum + pin.y, 0) / positionedPins.length;
-  const layerCounts = new Map;
-  for (const pin of positionedPins) {
-    const layer2 = pin.layers[0] ?? fallbackLayer;
-    layerCounts.set(layer2, (layerCounts.get(layer2) ?? 0) + 1);
-  }
-  const sortedLayers = [...layerCounts.entries()].sort((left, right) => {
-    if (right[1] !== left[1]) {
-      return right[1] - left[1];
-    }
-    return left[0].localeCompare(right[0]);
-  });
-  const layer = sortedLayers[0]?.[0] ?? fallbackLayer;
-  return { x: x3, y: y4, layer };
-}
-function measurePathLength(points) {
-  let lengthMm = 0;
-  for (let index = 1;index < points.length; index += 1) {
-    const previous = points[index - 1];
-    const current2 = points[index];
-    if (!previous || !current2) {
-      continue;
+    {
+      targetComponentName: targetComponent.sourceComponentName,
+      deltaSchX: 0,
+      deltaSchY,
+      newSchX: targetComponent.schX,
+      newSchY: targetComponent.schY + deltaSchY
     }
-    lengthMm += distanceBetween(previous, current2);
-  }
-  return lengthMm;
-}
-function dedupePcbTraces(pcbTraces) {
-  const seen = new Set;
-  const deduped = [];
-  for (const pcbTrace of pcbTraces) {
-    if (seen.has(pcbTrace)) {
-      continue;
+  ];
+};
+var generateSchematicPlacementIssues = (componentPlacements) => {
+  const issues = [];
+  for (let firstIndex = 0;firstIndex < componentPlacements.length; firstIndex++) {
+    for (let secondIndex = firstIndex + 1;secondIndex < componentPlacements.length; secondIndex++) {
+      const overlap = getComponentOverlap(componentPlacements[firstIndex], componentPlacements[secondIndex]);
+      if (overlap) {
+        issues.push(overlap);
+      }
     }
-    seen.add(pcbTrace);
-    deduped.push(pcbTrace);
   }
-  return deduped;
-}
-function normalizePcbTraceRoute(pcbTrace) {
-  if (!Array.isArray(pcbTrace.route)) {
-    return [];
+  return issues;
+};
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyze-schematic-placement.ts
+var fmtNumber5 = (value) => {
+  if (Number.isInteger(value))
+    return String(value);
+  return value.toFixed(3).replace(/\.0+$/, "").replace(/(\.\d*?)0+$/, "$1");
+};
+var fmtDelta = (value) => {
+  const formattedValue = fmtNumber5(value);
+  return value > 0 ? `+${formattedValue}` : formattedValue;
+};
+var isSchematicBox = (element) => element.type === "schematic_box";
+var isSchematicComponent = (element) => element.type === "schematic_component";
+var getSourceComponentName = (circuitJson, sourceComponentId) => {
+  if (!sourceComponentId)
+    return;
+  return cju7(circuitJson).source_component.get(sourceComponentId)?.name;
+};
+var schematicComponentToLineItem = (schematicComponent, circuitJson, schematicBox) => ({
+  lineItemType: "SchematicBoxPlacement",
+  positionAnchor: "center",
+  schX: schematicComponent.center.x,
+  schY: schematicComponent.center.y,
+  width: schematicBox?.width ?? schematicComponent.size.width,
+  height: schematicBox?.height ?? schematicComponent.size.height,
+  sourceComponentId: schematicComponent.source_component_id,
+  sourceComponentName: getSourceComponentName(circuitJson, schematicComponent.source_component_id),
+  schematicComponentId: schematicComponent.schematic_component_id,
+  schematicSymbolId: schematicBox?.schematic_symbol_id ?? schematicComponent.schematic_symbol_id,
+  subcircuitId: schematicComponent.subcircuit_id ?? schematicBox?.subcircuit_id
+});
+var schematicBoxToLineItem = (schematicBox, circuitJson) => ({
+  lineItemType: "SchematicBoxPlacement",
+  positionAnchor: "center",
+  schX: schematicBox.x,
+  schY: schematicBox.y,
+  width: schematicBox.width,
+  height: schematicBox.height,
+  ...getSourceComponentMetadata(schematicBox, circuitJson),
+  schematicComponentId: schematicBox.schematic_component_id,
+  schematicSymbolId: schematicBox.schematic_symbol_id,
+  subcircuitId: schematicBox.subcircuit_id
+});
+var getSourceComponentMetadata = (schematicBox, circuitJson) => {
+  if (!schematicBox.schematic_component_id)
+    return {};
+  const circuitJsonUtil = cju7(circuitJson);
+  const schematicComponent = circuitJsonUtil.schematic_component.get(schematicBox.schematic_component_id);
+  if (!schematicComponent?.source_component_id)
+    return {};
+  const sourceComponent = circuitJsonUtil.source_component.get(schematicComponent.source_component_id);
+  return {
+    sourceComponentId: schematicComponent.source_component_id,
+    sourceComponentName: sourceComponent?.name
+  };
+};
+var addAttr = (attrs, key, value, options) => {
+  if (value === undefined)
+    return;
+  attrs.push(`${key}="${typeof value === "number" ? options?.formatDelta ? fmtDelta(value) : fmtNumber5(value) : escapeAttr3(value)}"`);
+};
+var lineItemToString3 = (lineItem) => {
+  const attrs = [];
+  addAttr(attrs, "componentName", lineItem.sourceComponentName);
+  addAttr(attrs, "positionAnchor", lineItem.positionAnchor);
+  addAttr(attrs, "schX", lineItem.schX);
+  addAttr(attrs, "schY", lineItem.schY);
+  addAttr(attrs, "width", lineItem.width);
+  addAttr(attrs, "height", lineItem.height);
+  return `<SchematicBoxPlacement ${attrs.join(" ")} />`;
+};
+var overlapIssueToString = (issue) => {
+  const attrs = [];
+  addAttr(attrs, "component1Name", issue.firstComponent.sourceComponentName);
+  addAttr(attrs, "component2Name", issue.secondComponent.sourceComponentName);
+  addAttr(attrs, "component1SchX", issue.firstComponent.schX);
+  addAttr(attrs, "component1SchY", issue.firstComponent.schY);
+  addAttr(attrs, "component2SchX", issue.secondComponent.schX);
+  addAttr(attrs, "component2SchY", issue.secondComponent.schY);
+  addAttr(attrs, "overlapWidth", issue.overlapWidth);
+  addAttr(attrs, "overlapHeight", issue.overlapHeight);
+  return [
+    `<ComponentOverlap ${attrs.join(" ")}>`,
+    ...issue.correctionSuggestions.map(correctionSuggestionToString),
+    "</ComponentOverlap>"
+  ].join(`
+`);
+};
+var correctionSuggestionToString = (suggestion) => {
+  const attrs = [];
+  addAttr(attrs, "target", suggestion.targetComponentName);
+  if (suggestion.deltaSchX !== 0) {
+    addAttr(attrs, "newSchX", suggestion.newSchX);
+    addAttr(attrs, "deltaSchX", suggestion.deltaSchX, { formatDelta: true });
   }
-  return pcbTrace.route.filter((point5) => typeof point5.x === "number" && typeof point5.y === "number").map((point5) => ({
-    ...point5,
-    layer: typeof point5.layer === "string" && point5.layer.length > 0 ? point5.layer : typeof pcbTrace.layer === "string" && pcbTrace.layer.length > 0 ? pcbTrace.layer : "top"
-  }));
-}
-function convertPcbTraceRouteToPath(routePoints) {
-  const deduped = routePoints.filter((point5, index) => {
-    const previous = routePoints[index - 1];
-    return !previous || previous.x !== point5.x || previous.y !== point5.y || previous.layer !== point5.layer;
-  });
-  return deduped.map((point5, index) => ({
-    x: point5.x,
-    y: point5.y,
-    layer: point5.layer,
-    kind: classifyPcbTracePoint(point5, index, deduped.length)
-  }));
-}
-function classifyPcbTracePoint(point5, index, pointCount) {
-  if (point5.route_type === "via") {
-    return "via";
+  if (suggestion.deltaSchY !== 0) {
+    addAttr(attrs, "newSchY", suggestion.newSchY);
+    addAttr(attrs, "deltaSchY", suggestion.deltaSchY, { formatDelta: true });
   }
-  if (index === 0 || index === pointCount - 1 || point5.start_pcb_port_id || point5.end_pcb_port_id) {
-    return "endpoint";
+  return `<OverlapCorrectionSuggestion ${attrs.join(" ")} />`;
+};
+var escapeAttr3 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+
+class SchematicPlacementAnalysis {
+  lineItems;
+  constructor(lineItems) {
+    this.lineItems = lineItems;
   }
-  return "track";
-}
-function renderPinPosition(pin, indent) {
-  if (typeof pin.x !== "number" || typeof pin.y !== "number") {
-    return `${indent}<Pin ref="${escapeXml(pin.ref)}" position="unavailable" />`;
+  getLineItems() {
+    return this.lineItems;
   }
-  const layers = pin.layers.length > 0 ? pin.layers.join(",") : "unknown";
-  return `${indent}<Pin ref="${escapeXml(pin.ref)}" x="${formatNumber3(pin.x)}" y="${formatNumber3(pin.y)}" layers="${escapeXml(layers)}" />`;
-}
-function renderConnection(trace) {
-  if (trace.connectionTargetPosition) {
-    return `  <Connection kind="${escapeXml(trace.connectionType)}" target="${escapeXml(trace.connectionTarget)}" x="${formatNumber3(trace.connectionTargetPosition.x)}" y="${formatNumber3(trace.connectionTargetPosition.y)}" layer="${escapeXml(trace.connectionTargetPosition.layer)}" />`;
+  getString() {
+    return this.toString();
   }
-  return `  <Connection kind="${escapeXml(trace.connectionType)}" target="${escapeXml(trace.connectionTarget)}" />`;
-}
-function renderRequirements(requirements, indent) {
-  if (typeof requirements.maxLengthMm === "number") {
+  toString() {
+    const schematicBoxPlacements = this.lineItems.filter((lineItem) => lineItem.lineItemType === "SchematicBoxPlacement");
+    const issues = this.lineItems.flatMap((lineItem) => lineItem.lineItemType === "SchematicPlacementIssues" ? lineItem.issues : []);
     return [
-      `${indent}<TraceRequirements>`,
-      `${indent}  <MaxLengthMm>${formatNumber3(requirements.maxLengthMm)}</MaxLengthMm>`,
-      `${indent}</TraceRequirements>`
+      "<SchematicBoxPositions>",
+      ...schematicBoxPlacements.map(lineItemToString3),
+      "</SchematicBoxPositions>",
+      ...issues.length > 0 ? [
+        "<SchematicPlacementIssues>",
+        ...issues.map((issue) => {
+          switch (issue.lineItemType) {
+            case "ComponentOverlap":
+              return overlapIssueToString(issue);
+            default:
+              return "";
+          }
+        }),
+        "</SchematicPlacementIssues>"
+      ] : []
     ].join(`
 `);
   }
-  return `${indent}<TraceRequirements none />`;
-}
-function portMatchesLabel(port, label) {
-  const loweredLabel = label.toLowerCase();
-  const portName = port.name?.toLowerCase();
-  const pinNumber = String(port.pin_number ?? "").toLowerCase();
-  const portHints2 = (port.port_hints ?? []).map((hint) => hint.toLowerCase());
-  return portName === loweredLabel || pinNumber === loweredLabel || portHints2.includes(loweredLabel);
-}
-function prioritizeFocus(portIds, focusSourcePortId) {
-  const remainder = portIds.filter((portId) => portId !== focusSourcePortId);
-  return [focusSourcePortId, ...remainder];
-}
-function prioritizePin(focusPin, pins) {
-  const remainder = pins.filter((pin) => pin.ref !== focusPin.ref);
-  return [focusPin, ...remainder];
-}
-function compareTraceModels(left, right) {
-  return left.label.localeCompare(right.label);
-}
-function normalizeLayers(layers) {
-  if (!Array.isArray(layers)) {
-    return ["top"];
-  }
-  const normalizedLayers = layers.filter((layer) => typeof layer === "string" && layer.length > 0);
-  return normalizedLayers.length > 0 ? normalizedLayers : ["top"];
-}
-function primaryLayer(layers) {
-  return layers[0] ?? "top";
-}
-function distanceBetween(left, right) {
-  return Math.hypot(right.x - left.x, right.y - left.y);
-}
-function formatNumber3(value) {
-  return value.toFixed(2);
-}
-function escapeXml(value) {
-  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
+var analyzeSchematicPlacement = (circuitJson) => {
+  const schematicBoxes = circuitJson.filter(isSchematicBox);
+  const schematicComponentIds = new Set(circuitJson.filter(isSchematicComponent).map((schematicComponent) => schematicComponent.schematic_component_id));
+  const lineItems = [
+    ...circuitJson.filter(isSchematicComponent).map((schematicComponent) => schematicComponentToLineItem(schematicComponent, circuitJson, schematicBoxes.find((schematicBox) => schematicBox.schematic_component_id === schematicComponent.schematic_component_id))),
+    ...schematicBoxes.filter((schematicBox) => !schematicBox.schematic_component_id || !schematicComponentIds.has(schematicBox.schematic_component_id)).map((schematicBox) => schematicBoxToLineItem(schematicBox, circuitJson))
+  ];
+  const issues = generateSchematicPlacementIssues(lineItems);
+  return new SchematicPlacementAnalysis([
+    ...lineItems,
+    ...issues.length > 0 ? [{ lineItemType: "SchematicPlacementIssues", issues }] : []
+  ]);
+};
+// cli/check/schematic-placement/register.ts
+var checkSchematicPlacement = async (file) => {
+  const resolvedInputFilePath = await resolveCheckInputFilePath(file);
+  const circuitJson = await getCircuitJsonForCheck({
+    filePath: resolvedInputFilePath,
+    platformConfig: {
+      pcbDisabled: true,
+      routingDisabled: true,
+      placementDrcChecksDisabled: true
+    },
+    allowPrebuiltCircuitJson: true
+  });
+  return analyzeSchematicPlacement(circuitJson).getString();
+};
+var registerCheckSchematicPlacement = (program2) => {
+  program2.commands.find((c3) => c3.name() === "check").command("schematic-placement").description("Analyze schematic component placement").argument("[file]", "Path to the entry file").action(async (file) => {
+    try {
+      const output = await checkSchematicPlacement(file);
+      console.log(output);
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+};
+
 // cli/check/trace-length/register.ts
+var loadTraceLengthAnalyzer = async () => {
+  const mod = await Promise.resolve().then(() => (init_lib(), exports_lib));
+  return mod.analyzeCircuitJsonTraceLength;
+};
 var checkTraceLength = async (pinOrNetRef, file) => {
   const resolvedInputFilePath = await resolveCheckInputFilePath(file);
   const circuitJson = await getCircuitJsonForCheck({
@@ -241228,7 +241503,8 @@ var checkTraceLength = async (pinOrNetRef, file) => {
     },
     allowPrebuiltCircuitJson: true
   });
-  const analysis = analyzeCircuitJsonTraceLength(circuitJson, {
+  const analyzeCircuitJsonTraceLength2 = await loadTraceLengthAnalyzer();
+  const analysis = analyzeCircuitJsonTraceLength2(circuitJson, {
     targetPinOrNet: pinOrNetRef
   });
   return analysis.toString();
@@ -246291,8 +246567,8 @@ var warnIfTsconfigMissingTscircuitType = (projectDir) => {
   }
   try {
     const tsconfig = JSON.parse(fs51.readFileSync(tsconfigPath, "utf-8"));
-    const types = tsconfig?.compilerOptions?.types;
-    if (!Array.isArray(types) || !types.includes("tscircuit")) {
+    const types2 = tsconfig?.compilerOptions?.types;
+    if (!Array.isArray(types2) || !types2.includes("tscircuit")) {
       console.warn(kleur_default.yellow('Warning: "tscircuit" is missing from tsconfig.json compilerOptions.types. Add it (e.g. "types": ["tscircuit"]) to ensure CLI-provided types work correctly.'));
     }
   } catch {}
@@ -255424,9 +255700,9 @@ var ZodUnion2 = class extends ZodType2 {
     return this._def.options;
   }
 };
-ZodUnion2.create = (types, params2) => {
+ZodUnion2.create = (types2, params2) => {
   return new ZodUnion2({
-    options: types,
+    options: types2,
     typeName: ZodFirstPartyTypeKind3.ZodUnion,
     ...processCreateParams2(params2)
   });
@@ -260055,7 +260331,7 @@ function buildSubtree2(soup, opts) {
   }
   return soup.filter((e4) => included.has(e4));
 }
-var cju7 = (circuitJsonInput, options = {}) => {
+var cju8 = (circuitJsonInput, options = {}) => {
   const circuitJson = circuitJsonInput;
   let internalStore = circuitJson._internal_store;
   if (!internalStore) {
@@ -260087,7 +260363,7 @@ var cju7 = (circuitJsonInput, options = {}) => {
         return internalStore.editCount;
       }
       if (prop === "subtree") {
-        return (opts) => cju7(buildSubtree2(circuitJson, opts), options);
+        return (opts) => cju8(buildSubtree2(circuitJson, opts), options);
       }
       if (prop === "insert") {
         return (elm) => {
@@ -260197,8 +260473,8 @@ var cju7 = (circuitJsonInput, options = {}) => {
   });
   return su24;
 };
-cju7.unparsed = cju7;
-var su9 = cju7;
+cju8.unparsed = cju8;
+var su9 = cju8;
 function createIdKey2(element) {
   const type = element.type;
   return `${type}:${element[`${type}_id`]}`;
@@ -266614,7 +266890,7 @@ function buildSubtree3(soup, opts) {
   }
   return soup.filter((e4) => included.has(e4));
 }
-var cju8 = (circuitJsonInput, options = {}) => {
+var cju9 = (circuitJsonInput, options = {}) => {
   const circuitJson = circuitJsonInput;
   let internalStore = circuitJson._internal_store;
   if (!internalStore) {
@@ -266646,7 +266922,7 @@ var cju8 = (circuitJsonInput, options = {}) => {
         return internalStore.editCount;
       }
       if (prop === "subtree") {
-        return (opts) => cju8(buildSubtree3(circuitJson, opts), options);
+        return (opts) => cju9(buildSubtree3(circuitJson, opts), options);
       }
       if (prop === "insert") {
         return (elm) => {
@@ -266756,7 +267032,7 @@ var cju8 = (circuitJsonInput, options = {}) => {
   });
   return su24;
 };
-cju8.unparsed = cju8;
+cju9.unparsed = cju9;
 function createIdKey3(element) {
   const type = element.type;
   return `${type}:${element[`${type}_id`]}`;
@@ -272512,7 +272788,7 @@ import fs63 from "node:fs";
 import path66 from "node:path";
 import {
   convertCircuitJsonToGltf as convertCircuitJsonToGltf5,
-  getBestCameraPosition
+  getBestCameraPosition as getBestCameraPosition2
 } from "circuit-json-to-gltf";
 import {
   convertCircuitJsonToPcbSvg as convertCircuitJsonToPcbSvg4,
@@ -275323,7 +275599,7 @@ var processSnapshotFile = async ({
       if (!(glbBuffer instanceof ArrayBuffer)) {
         throw new Error("Expected ArrayBuffer from convertCircuitJsonToGltf with glb format");
       }
-      let cameraOptions = getBestCameraPosition(circuitJson);
+      let cameraOptions = getBestCameraPosition2(circuitJson);
       if (cameraPreset) {
         cameraOptions = applyCameraPreset(cameraPreset, cameraOptions);
       }
@@ -275748,6 +276024,7 @@ registerCheckPinSpecification(program2);
 registerCheckPlacement(program2);
 registerCheckRoutingDifficulty(program2);
 registerCheckRouting(program2);
+registerCheckSchematicPlacement(program2);
 registerCheckTraceLength(program2);
 registerRegistry(program2);
 registerRegistryPackages(program2);