@tscircuit/core 0.0.550 → 0.0.552

package/dist/index.js

@@ -54,7 +54,7 @@ __export(components_exports, {
   Subcircuit: () => Subcircuit,
   Switch: () => Switch,
   TestPoint: () => TestPoint,
-  Trace: () => Trace2,
+  Trace: () => Trace3,
   TraceHint: () => TraceHint,
   Transistor: () => Transistor,
   Via: () => Via
@@ -3602,10 +3602,10 @@ var getNumericSchPinStyle = (pinStyles, pinLabels) => {
 };
 
 // lib/components/primitive-components/Trace/Trace.ts
-import { MultilayerIjump } from "@tscircuit/infgrid-ijump-astar";
+import "@tscircuit/infgrid-ijump-astar";
 import { traceProps } from "@tscircuit/props";
 import "circuit-json";
-import { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectivity-map";
+import "circuit-json-to-connectivity-map";
 
 // lib/utils/autorouting/DirectLineRouter.ts
 var DirectLineRouter = class {
@@ -3890,198 +3890,7 @@ function tryNow(fn) {
 // lib/components/primitive-components/Trace/Trace.ts
 import "zod";
 
-// lib/components/primitive-components/Trace/compute-trace-length.ts
-function getTraceLength(route) {
-  let totalLength = 0;
-  for (let i = 0; i < route.length; i++) {
-    const point = route[i];
-    if (point.route_type === "wire") {
-      const nextPoint = route[i + 1];
-      if (nextPoint) {
-        const dx = nextPoint.x - point.x;
-        const dy = nextPoint.y - point.y;
-        totalLength += Math.sqrt(dx * dx + dy * dy);
-      }
-    } else if (point.route_type === "via") {
-      totalLength += 1.6;
-    }
-  }
-  return totalLength;
-}
-
-// lib/components/primitive-components/Trace/create-schematic-trace-crossing-segments.ts
-import { distance as distance2, doesLineIntersectLine } from "@tscircuit/math-utils";
-
-// lib/components/primitive-components/Trace/get-other-schematic-traces.ts
-var getOtherSchematicTraces = ({
-  db,
-  source_trace_id,
-  sameNetOnly,
-  differentNetOnly
-}) => {
-  if (!sameNetOnly && !differentNetOnly) {
-    differentNetOnly = true;
-  }
-  const mySourceTrace = db.source_trace.get(source_trace_id);
-  const traces = [];
-  for (const otherSchematicTrace of db.schematic_trace.list()) {
-    if (otherSchematicTrace.source_trace_id === source_trace_id) continue;
-    const otherSourceTrace = db.source_trace.get(
-      otherSchematicTrace.source_trace_id
-    );
-    const isSameNet = otherSourceTrace?.subcircuit_connectivity_map_key === mySourceTrace.subcircuit_connectivity_map_key;
-    if (differentNetOnly && isSameNet) {
-      continue;
-    }
-    if (sameNetOnly && !isSameNet) {
-      continue;
-    }
-    traces.push(otherSchematicTrace);
-  }
-  return traces;
-};
-
-// lib/components/primitive-components/Trace/create-schematic-trace-crossing-segments.ts
-import { getUnitVectorFromPointAToB } from "@tscircuit/math-utils";
-var createSchematicTraceCrossingSegments = ({
-  edges: inputEdges,
-  otherEdges
-}) => {
-  const edges = [...inputEdges];
-  for (let i = 0; i < edges.length; i++) {
-    if (i > 2e3) {
-      throw new Error(
-        "Over 2000 iterations spent inside createSchematicTraceCrossingSegments, you have triggered an infinite loop, please report this!"
-      );
-    }
-    const edge = edges[i];
-    const edgeOrientation = Math.abs(edge.from.x - edge.to.x) < 0.01 ? "vertical" : edge.from.y === edge.to.y ? "horizontal" : "not-orthogonal";
-    if (edgeOrientation === "not-orthogonal") {
-      continue;
-    }
-    const otherEdgesIntersections = [];
-    for (const otherEdge of otherEdges) {
-      const otherOrientation = otherEdge.from.x === otherEdge.to.x ? "vertical" : otherEdge.from.y === otherEdge.to.y ? "horizontal" : "not-orthogonal";
-      if (otherOrientation === "not-orthogonal") continue;
-      if (edgeOrientation === otherOrientation)
-        continue;
-      const hasIntersection = doesLineIntersectLine(
-        [edge.from, edge.to],
-        [otherEdge.from, otherEdge.to],
-        { lineThickness: 0.01 }
-      );
-      if (hasIntersection) {
-        const intersectX = edgeOrientation === "vertical" ? edge.from.x : otherEdge.from.x;
-        const intersectY = edgeOrientation === "vertical" ? otherEdge.from.y : edge.from.y;
-        const crossingPoint2 = { x: intersectX, y: intersectY };
-        otherEdgesIntersections.push({
-          otherEdge,
-          crossingPoint: crossingPoint2,
-          distanceFromEdgeFrom: distance2(edge.from, crossingPoint2)
-        });
-      }
-    }
-    if (otherEdgesIntersections.length === 0) continue;
-    let closestIntersection = otherEdgesIntersections[0];
-    for (const intersection of otherEdgesIntersections) {
-      if (intersection.distanceFromEdgeFrom < closestIntersection.distanceFromEdgeFrom) {
-        closestIntersection = intersection;
-      }
-    }
-    const crossingPoint = closestIntersection.crossingPoint;
-    const crossingSegmentLength = 0.075;
-    if (crossingPoint.x === edge.from.x && crossingPoint.y === edge.from.y) {
-      continue;
-    }
-    const crossingUnitVec = getUnitVectorFromPointAToB(edge.from, crossingPoint);
-    const beforeCrossing = {
-      x: crossingPoint.x - crossingUnitVec.x * crossingSegmentLength / 2,
-      y: crossingPoint.y - crossingUnitVec.y * crossingSegmentLength / 2
-    };
-    const afterCrossing = {
-      x: crossingPoint.x + crossingUnitVec.x * crossingSegmentLength / 2,
-      y: crossingPoint.y + crossingUnitVec.y * crossingSegmentLength / 2
-    };
-    const overshot = distance2(afterCrossing, edge.to) < crossingSegmentLength;
-    const newEdges = [
-      { from: edge.from, to: beforeCrossing },
-      { from: beforeCrossing, to: afterCrossing, is_crossing: true },
-      { from: afterCrossing, to: edge.to }
-    ];
-    edges.splice(i, 1, ...newEdges);
-    i += newEdges.length - 2;
-    if (overshot) {
-      i++;
-    }
-  }
-  return edges;
-};
-
-// lib/components/primitive-components/Trace/create-schematic-trace-junctions.ts
-var getIntersectionPoint = (edge1, edge2) => {
-  if (edge1.from.x === edge1.to.x && edge2.from.x === edge2.to.x) {
-    return null;
-  }
-  if (edge1.from.x === edge1.to.x) {
-    const x2 = edge1.from.x;
-    const m22 = (edge2.to.y - edge2.from.y) / (edge2.to.x - edge2.from.x);
-    const b22 = edge2.from.y - m22 * edge2.from.x;
-    const y2 = m22 * x2 + b22;
-    if (x2 >= Math.min(edge2.from.x, edge2.to.x) && x2 <= Math.max(edge2.from.x, edge2.to.x) && y2 >= Math.min(edge2.from.y, edge2.to.y) && y2 <= Math.max(edge2.from.y, edge2.to.y)) {
-      return { x: x2, y: y2 };
-    }
-    return null;
-  }
-  if (edge2.from.x === edge2.to.x) {
-    const x2 = edge2.from.x;
-    const m12 = (edge1.to.y - edge1.from.y) / (edge1.to.x - edge1.from.x);
-    const b12 = edge1.from.y - m12 * edge1.from.x;
-    const y2 = m12 * x2 + b12;
-    if (x2 >= Math.min(edge1.from.x, edge1.to.x) && x2 <= Math.max(edge1.from.x, edge1.to.x) && y2 >= Math.min(edge1.from.y, edge1.to.y) && y2 <= Math.max(edge1.from.y, edge1.to.y)) {
-      return { x: x2, y: y2 };
-    }
-    return null;
-  }
-  const m1 = (edge1.to.y - edge1.from.y) / (edge1.to.x - edge1.from.x);
-  const b1 = edge1.from.y - m1 * edge1.from.x;
-  const m2 = (edge2.to.y - edge2.from.y) / (edge2.to.x - edge2.from.x);
-  const b2 = edge2.from.y - m2 * edge2.from.x;
-  if (m1 === m2) {
-    return null;
-  }
-  const x = (b2 - b1) / (m1 - m2);
-  const y = m1 * x + b1;
-  const isWithinEdge1 = x >= Math.min(edge1.from.x, edge1.to.x) && x <= Math.max(edge1.from.x, edge1.to.x) && y >= Math.min(edge1.from.y, edge1.to.y) && y <= Math.max(edge1.from.y, edge1.to.y);
-  const isWithinEdge2 = x >= Math.min(edge2.from.x, edge2.to.x) && x <= Math.max(edge2.from.x, edge2.to.x) && y >= Math.min(edge2.from.y, edge2.to.y) && y <= Math.max(edge2.from.y, edge2.to.y);
-  if (isWithinEdge1 && isWithinEdge2) {
-    return { x, y };
-  }
-  return null;
-};
-var createSchematicTraceJunctions = ({
-  edges: myEdges,
-  db,
-  source_trace_id
-}) => {
-  const otherEdges = getOtherSchematicTraces({
-    db,
-    source_trace_id,
-    sameNetOnly: true
-  }).flatMap((t) => t.edges);
-  const junctions = /* @__PURE__ */ new Set();
-  for (const myEdge of myEdges) {
-    for (const otherEdge of otherEdges) {
-      const intersection = getIntersectionPoint(myEdge, otherEdge);
-      if (intersection) {
-        const pointKey = `${intersection.x},${intersection.y}`;
-        return [{ x: intersection.x, y: intersection.y }];
-      }
-    }
-  }
-  return [];
-};
-
-// lib/components/primitive-components/Trace/get-max-length-from-connected-capacitors.ts
+// lib/components/primitive-components/Trace/trace-utils/get-max-length-from-connected-capacitors.ts
 var getMaxLengthFromConnectedCapacitors = (ports, { db }) => {
   const capacitorMaxLengths = ports.map((port) => {
     const sourcePort = db.source_port.get(port.source_port_id);
@@ -4098,219 +3907,20 @@ var getMaxLengthFromConnectedCapacitors = (ports, { db }) => {
   return Math.min(...capacitorMaxLengths);
 };
 
-// lib/components/primitive-components/Trace/get-obstacles-for-trace.ts
-import { getUnitVectorFromDirection } from "@tscircuit/math-utils";
-
-// lib/utils/autorouting/getBoundsForSchematic.ts
-function getBoundsForSchematic(db) {
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (const elm of db) {
-    let cx, cy, w, h;
-    if (elm.type === "schematic_component") {
-      cx = elm.center?.x;
-      cy = elm.center?.y;
-      w = elm.size?.width;
-      h = elm.size?.height;
-    } else if (elm.type === "schematic_box") {
-      cx = elm.x;
-      cy = elm.y;
-      w = elm.width;
-      h = elm.height;
-    } else if (elm.type === "schematic_port") {
-      cx = elm.center?.x;
-      cy = elm.center?.y;
-      w = 0.2;
-      h = 0.2;
-    } else if (elm.type === "schematic_text") {
-      cx = elm.position?.x;
-      cy = elm.position?.y;
-      w = (elm.text?.length ?? 0) * 0.1;
-      h = 0.2;
-    }
-    if (typeof cx === "number" && typeof cy === "number" && typeof w === "number" && typeof h === "number") {
-      minX = Math.min(minX, cx - w / 2);
-      maxX = Math.max(maxX, cx + w / 2);
-      minY = Math.min(minY, cy - h / 2);
-      maxY = Math.max(maxY, cy + h / 2);
-    }
+// lib/components/primitive-components/Trace/trace-utils/get-trace-display-name.ts
+function getTraceDisplayName({
+  ports,
+  nets
+}) {
+  if (ports.length >= 2) {
+    return `${ports[0]?.selector} to ${ports[1]?.selector}`;
   }
-  return { minX, maxX, minY, maxY };
+  if (ports.length === 1 && nets.length === 1) {
+    return `${ports[0]?.selector} to net.${nets[0]._parsedProps.name}`;
+  }
+  return void 0;
 }
 
-// lib/utils/autorouting/getObstaclesFromBounds.ts
-function getObstaclesFromBounds(bounds, opts = {}) {
-  const { minX, maxX, minY, maxY } = bounds;
-  const PADDING = opts.padding ?? 1;
-  if (!isFinite(minX) || !isFinite(maxX) || !isFinite(minY) || !isFinite(maxY))
-    return [];
-  const left = minX - PADDING;
-  const right = maxX + PADDING;
-  const top = maxY + PADDING;
-  const bottom = minY - PADDING;
-  const thickness = 0.01;
-  return [
-    // Top border (horizontal)
-    {
-      type: "rect",
-      layers: ["top"],
-      center: { x: (left + right) / 2, y: top },
-      width: right - left,
-      height: thickness,
-      connectedTo: []
-    },
-    // Bottom border (horizontal)
-    {
-      type: "rect",
-      layers: ["top"],
-      center: { x: (left + right) / 2, y: bottom },
-      width: right - left,
-      height: thickness,
-      connectedTo: []
-    },
-    // Left border (vertical)
-    {
-      type: "rect",
-      layers: ["top"],
-      center: { x: left, y: (top + bottom) / 2 },
-      width: thickness,
-      height: top - bottom,
-      connectedTo: []
-    },
-    // Right border (vertical)
-    {
-      type: "rect",
-      layers: ["top"],
-      center: { x: right, y: (top + bottom) / 2 },
-      width: thickness,
-      height: top - bottom,
-      connectedTo: []
-    }
-  ];
-}
-
-// lib/components/primitive-components/Trace/get-obstacles-for-trace.ts
-var getSchematicObstaclesForTrace = (trace) => {
-  const db = trace.root.db;
-  const connectedPorts = trace._findConnectedPorts().ports ?? [];
-  const connectedPortIds = new Set(
-    connectedPorts.map((p) => p.schematic_port_id)
-  );
-  const obstacles = [];
-  for (const elm of db.toArray()) {
-    if (elm.type === "schematic_component") {
-      const isSymbol = Boolean(elm.symbol_name);
-      const dominateAxis = elm.size.width > elm.size.height ? "horz" : "vert";
-      obstacles.push({
-        type: "rect",
-        layers: ["top"],
-        center: elm.center,
-        width: elm.size.width + (isSymbol && dominateAxis === "horz" ? -0.5 : 0),
-        height: elm.size.height + (isSymbol && dominateAxis === "vert" ? -0.5 : 0),
-        connectedTo: []
-      });
-    }
-    if (elm.type === "schematic_port") {
-      if (connectedPortIds.has(elm.schematic_port_id)) {
-        continue;
-      }
-      const dirVec = elm.facing_direction ? getUnitVectorFromDirection(elm.facing_direction) : {
-        x: 0,
-        y: 0
-      };
-      obstacles.push({
-        type: "rect",
-        layers: ["top"],
-        center: {
-          x: elm.center.x - dirVec.x * 0.1,
-          y: elm.center.y - dirVec.y * 0.1
-        },
-        width: 0.1 + Math.abs(dirVec.x) * 0.3,
-        height: 0.1 + Math.abs(dirVec.y) * 0.3,
-        connectedTo: []
-      });
-    }
-    if (elm.type === "schematic_text") {
-      obstacles.push({
-        type: "rect",
-        layers: ["top"],
-        center: elm.position,
-        width: (elm.text?.length ?? 0) * 0.1,
-        height: 0.2,
-        connectedTo: []
-      });
-    }
-    if (elm.type === "schematic_box") {
-      obstacles.push({
-        type: "rect",
-        layers: ["top"],
-        center: { x: elm.x, y: elm.y },
-        width: elm.width,
-        height: elm.height,
-        connectedTo: []
-      });
-    }
-  }
-  const bounds = getBoundsForSchematic(db.toArray());
-  obstacles.push(...getObstaclesFromBounds(bounds, { padding: 1 }));
-  return obstacles;
-};
-
-// lib/components/primitive-components/Trace/get-trace-display-name.ts
-function getTraceDisplayName({
-  ports,
-  nets
-}) {
-  if (ports.length >= 2) {
-    return `${ports[0]?.selector} to ${ports[1]?.selector}`;
-  }
-  if (ports.length === 1 && nets.length === 1) {
-    return `${ports[0]?.selector} to net.${nets[0]._parsedProps.name}`;
-  }
-  return void 0;
-}
-
-// lib/components/primitive-components/Trace/push-edges-of-schematic-trace-to-prevent-overlap.ts
-import { doesLineIntersectLine as doesLineIntersectLine2 } from "@tscircuit/math-utils";
-var pushEdgesOfSchematicTraceToPreventOverlap = ({
-  edges,
-  db,
-  source_trace_id
-}) => {
-  const mySourceTrace = db.source_trace.get(source_trace_id);
-  const otherEdges = getOtherSchematicTraces({
-    db,
-    source_trace_id,
-    differentNetOnly: true
-  }).flatMap((t) => t.edges);
-  const edgeOrientation = (edge) => {
-    const { from, to } = edge;
-    return from.x === to.x ? "vertical" : "horizontal";
-  };
-  for (const mySegment of edges) {
-    const mySegmentOrientation = edgeOrientation(mySegment);
-    const findOverlappingParallelSegment = () => otherEdges.find(
-      (otherEdge) => edgeOrientation(otherEdge) === mySegmentOrientation && doesLineIntersectLine2(
-        [mySegment.from, mySegment.to],
-        [otherEdge.from, otherEdge.to],
-        {
-          lineThickness: 0.05
-        }
-      )
-    );
-    let overlappingParallelSegmentFromOtherTrace = findOverlappingParallelSegment();
-    while (overlappingParallelSegmentFromOtherTrace) {
-      if (mySegmentOrientation === "horizontal") {
-        mySegment.from.y += 0.1;
-        mySegment.to.y += 0.1;
-      } else {
-        mySegment.from.x += 0.1;
-        mySegment.to.x += 0.1;
-      }
-      overlappingParallelSegmentFromOtherTrace = findOverlappingParallelSegment();
-    }
-  }
-};
-
 // lib/utils/is-route-outside-board.ts
 var isRouteOutsideBoard = (mergedRoute, { db }) => {
   const pcbBoard = db.pcb_board.list()[0];
@@ -4760,122 +4370,1116 @@ var computeSchematicNetLabelCenter = ({
   return center;
 };
 
-// lib/components/primitive-components/Trace/Trace.ts
-var portToObjective = (port) => {
-  const portPosition = port._getGlobalPcbPositionAfterLayout();
-  return {
-    ...portPosition,
-    layers: port.getAvailablePcbLayers()
-  };
-};
-var SHOULD_USE_SINGLE_LAYER_ROUTING = false;
-var Trace2 = class extends PrimitiveComponent2 {
-  source_trace_id = null;
-  pcb_trace_id = null;
-  schematic_trace_id = null;
-  _portsRoutedOnPcb;
-  subcircuit_connectivity_map_key = null;
-  _traceConnectionHash = null;
-  constructor(props) {
-    super(props);
-    this._portsRoutedOnPcb = [];
-  }
-  get config() {
-    return {
-      zodProps: traceProps,
-      componentName: "Trace"
-    };
+// lib/components/primitive-components/Trace/Trace_doInitialSchematicTraceRender.ts
+import { MultilayerIjump } from "@tscircuit/infgrid-ijump-astar";
+import "circuit-json";
+
+// lib/components/primitive-components/Trace/trace-utils/create-schematic-trace-crossing-segments.ts
+import { distance as distance2, doesLineIntersectLine } from "@tscircuit/math-utils";
+
+// lib/components/primitive-components/Trace/trace-utils/get-other-schematic-traces.ts
+var getOtherSchematicTraces = ({
+  db,
+  source_trace_id,
+  sameNetOnly,
+  differentNetOnly
+}) => {
+  if (!sameNetOnly && !differentNetOnly) {
+    differentNetOnly = true;
   }
-  _getTracePortOrNetSelectorListFromProps() {
-    if ("from" in this.props && "to" in this.props) {
-      return [
-        typeof this.props.from === "string" ? this.props.from : this.props.from.getPortSelector(),
-        typeof this.props.to === "string" ? this.props.to : this.props.to.getPortSelector()
-      ];
+  const mySourceTrace = db.source_trace.get(source_trace_id);
+  const traces = [];
+  for (const otherSchematicTrace of db.schematic_trace.list()) {
+    if (otherSchematicTrace.source_trace_id === source_trace_id) continue;
+    const otherSourceTrace = db.source_trace.get(
+      otherSchematicTrace.source_trace_id
+    );
+    const isSameNet = otherSourceTrace?.subcircuit_connectivity_map_key === mySourceTrace.subcircuit_connectivity_map_key;
+    if (differentNetOnly && isSameNet) {
+      continue;
     }
-    if ("path" in this.props) {
-      return this.props.path.map(
-        (p) => typeof p === "string" ? p : p.getPortSelector()
-      );
+    if (sameNetOnly && !isSameNet) {
+      continue;
     }
-    return [];
-  }
-  getTracePortPathSelectors() {
-    return this._getTracePortOrNetSelectorListFromProps().filter(
-      (selector) => !selector.includes("net.")
-    );
-  }
-  getTracePathNetSelectors() {
-    return this._getTracePortOrNetSelectorListFromProps().filter(
-      (selector) => selector.includes("net.")
-    );
+    traces.push(otherSchematicTrace);
   }
-  _findConnectedPorts() {
-    const { db } = this.root;
-    const { _parsedProps: props, parent } = this;
-    if (!parent) throw new Error("Trace has no parent");
-    const portSelectors = this.getTracePortPathSelectors();
-    const portsWithSelectors = portSelectors.map((selector) => ({
-      selector,
-      port: this.getSubcircuit().selectOne(selector, { type: "port" }) ?? null
-    }));
-    for (const { selector, port } of portsWithSelectors) {
-      if (!port) {
-        let parentSelector;
-        let portToken;
-        const dotIndex = selector.lastIndexOf(".");
-        if (dotIndex !== -1 && dotIndex > selector.lastIndexOf(" ")) {
-          parentSelector = selector.slice(0, dotIndex);
-          portToken = selector.slice(dotIndex + 1);
-        } else {
-          const match = selector.match(/^(.*[ >])?([^ >]+)$/);
-          parentSelector = match?.[1]?.trim() ?? "";
-          portToken = match?.[2] ?? selector;
-        }
-        let targetComponent = parentSelector ? this.getSubcircuit().selectOne(parentSelector) : null;
-        if (!targetComponent && parentSelector && !/[.#\[]/.test(parentSelector)) {
-          targetComponent = this.getSubcircuit().selectOne(`.${parentSelector}`);
-        }
-        if (!targetComponent) {
-          if (parentSelector) {
-            this.renderError(
-              `Could not find port for selector "${selector}". Component "${parentSelector}" not found`
-            );
-          } else {
-            this.renderError(`Could not find port for selector "${selector}"`);
-          }
-        } else {
-          const ports = targetComponent.children.filter(
-            (c) => c.componentName === "Port"
-          );
-          const portLabel = portToken.includes(".") ? portToken.split(".").pop() ?? "" : portToken;
-          const portNames = ports.map((c) => c.getNameAndAliases()).flat();
-          const hasCustomLabels = portNames.some(
-            (n) => !/^(pin\d+|\d+)$/.test(n)
-          );
-          const labelList = Array.from(new Set(portNames)).join(", ");
-          let detail;
-          if (ports.length === 0) {
-            detail = "It has no ports";
-          } else if (!hasCustomLabels) {
-            detail = `It has ${ports.length} pins and no pinLabels (consider adding pinLabels)`;
-          } else {
-            detail = `It has [${labelList}]`;
-          }
-          this.renderError(
-            `Could not find port for selector "${selector}". Component "${targetComponent.props.name ?? parentSelector}" found, but does not have pin "${portLabel}". ${detail}`
-          );
-        }
-      }
+  return traces;
+};
+
+// lib/components/primitive-components/Trace/trace-utils/create-schematic-trace-crossing-segments.ts
+import { getUnitVectorFromPointAToB } from "@tscircuit/math-utils";
+var createSchematicTraceCrossingSegments = ({
+  edges: inputEdges,
+  otherEdges
+}) => {
+  const edges = [...inputEdges];
+  for (let i = 0; i < edges.length; i++) {
+    if (i > 2e3) {
+      throw new Error(
+        "Over 2000 iterations spent inside createSchematicTraceCrossingSegments, you have triggered an infinite loop, please report this!"
+      );
     }
-    if (portsWithSelectors.some((p) => !p.port)) {
-      return { allPortsFound: false };
+    const edge = edges[i];
+    const edgeOrientation = Math.abs(edge.from.x - edge.to.x) < 0.01 ? "vertical" : edge.from.y === edge.to.y ? "horizontal" : "not-orthogonal";
+    if (edgeOrientation === "not-orthogonal") {
+      continue;
+    }
+    const otherEdgesIntersections = [];
+    for (const otherEdge of otherEdges) {
+      const otherOrientation = otherEdge.from.x === otherEdge.to.x ? "vertical" : otherEdge.from.y === otherEdge.to.y ? "horizontal" : "not-orthogonal";
+      if (otherOrientation === "not-orthogonal") continue;
+      if (edgeOrientation === otherOrientation)
+        continue;
+      const hasIntersection = doesLineIntersectLine(
+        [edge.from, edge.to],
+        [otherEdge.from, otherEdge.to],
+        { lineThickness: 0.01 }
+      );
+      if (hasIntersection) {
+        const intersectX = edgeOrientation === "vertical" ? edge.from.x : otherEdge.from.x;
+        const intersectY = edgeOrientation === "vertical" ? otherEdge.from.y : edge.from.y;
+        const crossingPoint2 = { x: intersectX, y: intersectY };
+        otherEdgesIntersections.push({
+          otherEdge,
+          crossingPoint: crossingPoint2,
+          distanceFromEdgeFrom: distance2(edge.from, crossingPoint2)
+        });
+      }
+    }
+    if (otherEdgesIntersections.length === 0) continue;
+    let closestIntersection = otherEdgesIntersections[0];
+    for (const intersection of otherEdgesIntersections) {
+      if (intersection.distanceFromEdgeFrom < closestIntersection.distanceFromEdgeFrom) {
+        closestIntersection = intersection;
+      }
+    }
+    const crossingPoint = closestIntersection.crossingPoint;
+    const crossingSegmentLength = 0.075;
+    if (crossingPoint.x === edge.from.x && crossingPoint.y === edge.from.y) {
+      continue;
+    }
+    const crossingUnitVec = getUnitVectorFromPointAToB(edge.from, crossingPoint);
+    const beforeCrossing = {
+      x: crossingPoint.x - crossingUnitVec.x * crossingSegmentLength / 2,
+      y: crossingPoint.y - crossingUnitVec.y * crossingSegmentLength / 2
+    };
+    const afterCrossing = {
+      x: crossingPoint.x + crossingUnitVec.x * crossingSegmentLength / 2,
+      y: crossingPoint.y + crossingUnitVec.y * crossingSegmentLength / 2
+    };
+    const overshot = distance2(afterCrossing, edge.to) < crossingSegmentLength;
+    const newEdges = [
+      { from: edge.from, to: beforeCrossing },
+      { from: beforeCrossing, to: afterCrossing, is_crossing: true },
+      { from: afterCrossing, to: edge.to }
+    ];
+    edges.splice(i, 1, ...newEdges);
+    i += newEdges.length - 2;
+    if (overshot) {
+      i++;
+    }
+  }
+  return edges;
+};
+
+// lib/components/primitive-components/Trace/trace-utils/create-schematic-trace-junctions.ts
+var getIntersectionPoint = (edge1, edge2) => {
+  if (edge1.from.x === edge1.to.x && edge2.from.x === edge2.to.x) {
+    return null;
+  }
+  if (edge1.from.x === edge1.to.x) {
+    const x2 = edge1.from.x;
+    const m22 = (edge2.to.y - edge2.from.y) / (edge2.to.x - edge2.from.x);
+    const b22 = edge2.from.y - m22 * edge2.from.x;
+    const y2 = m22 * x2 + b22;
+    if (x2 >= Math.min(edge2.from.x, edge2.to.x) && x2 <= Math.max(edge2.from.x, edge2.to.x) && y2 >= Math.min(edge2.from.y, edge2.to.y) && y2 <= Math.max(edge2.from.y, edge2.to.y)) {
+      return { x: x2, y: y2 };
+    }
+    return null;
+  }
+  if (edge2.from.x === edge2.to.x) {
+    const x2 = edge2.from.x;
+    const m12 = (edge1.to.y - edge1.from.y) / (edge1.to.x - edge1.from.x);
+    const b12 = edge1.from.y - m12 * edge1.from.x;
+    const y2 = m12 * x2 + b12;
+    if (x2 >= Math.min(edge1.from.x, edge1.to.x) && x2 <= Math.max(edge1.from.x, edge1.to.x) && y2 >= Math.min(edge1.from.y, edge1.to.y) && y2 <= Math.max(edge1.from.y, edge1.to.y)) {
+      return { x: x2, y: y2 };
+    }
+    return null;
+  }
+  const m1 = (edge1.to.y - edge1.from.y) / (edge1.to.x - edge1.from.x);
+  const b1 = edge1.from.y - m1 * edge1.from.x;
+  const m2 = (edge2.to.y - edge2.from.y) / (edge2.to.x - edge2.from.x);
+  const b2 = edge2.from.y - m2 * edge2.from.x;
+  if (m1 === m2) {
+    return null;
+  }
+  const x = (b2 - b1) / (m1 - m2);
+  const y = m1 * x + b1;
+  const isWithinEdge1 = x >= Math.min(edge1.from.x, edge1.to.x) && x <= Math.max(edge1.from.x, edge1.to.x) && y >= Math.min(edge1.from.y, edge1.to.y) && y <= Math.max(edge1.from.y, edge1.to.y);
+  const isWithinEdge2 = x >= Math.min(edge2.from.x, edge2.to.x) && x <= Math.max(edge2.from.x, edge2.to.x) && y >= Math.min(edge2.from.y, edge2.to.y) && y <= Math.max(edge2.from.y, edge2.to.y);
+  if (isWithinEdge1 && isWithinEdge2) {
+    return { x, y };
+  }
+  return null;
+};
+var createSchematicTraceJunctions = ({
+  edges: myEdges,
+  db,
+  source_trace_id
+}) => {
+  const otherEdges = getOtherSchematicTraces({
+    db,
+    source_trace_id,
+    sameNetOnly: true
+  }).flatMap((t) => t.edges);
+  const junctions = /* @__PURE__ */ new Set();
+  for (const myEdge of myEdges) {
+    for (const otherEdge of otherEdges) {
+      const intersection = getIntersectionPoint(myEdge, otherEdge);
+      if (intersection) {
+        const pointKey = `${intersection.x},${intersection.y}`;
+        return [{ x: intersection.x, y: intersection.y }];
+      }
+    }
+  }
+  return [];
+};
+
+// lib/components/primitive-components/Trace/trace-utils/get-obstacles-for-trace.ts
+import { getUnitVectorFromDirection } from "@tscircuit/math-utils";
+
+// lib/utils/autorouting/getBoundsForSchematic.ts
+function getBoundsForSchematic(db) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const elm of db) {
+    let cx, cy, w, h;
+    if (elm.type === "schematic_component") {
+      cx = elm.center?.x;
+      cy = elm.center?.y;
+      w = elm.size?.width;
+      h = elm.size?.height;
+    } else if (elm.type === "schematic_box") {
+      cx = elm.x;
+      cy = elm.y;
+      w = elm.width;
+      h = elm.height;
+    } else if (elm.type === "schematic_port") {
+      cx = elm.center?.x;
+      cy = elm.center?.y;
+      w = 0.2;
+      h = 0.2;
+    } else if (elm.type === "schematic_text") {
+      cx = elm.position?.x;
+      cy = elm.position?.y;
+      w = (elm.text?.length ?? 0) * 0.1;
+      h = 0.2;
+    }
+    if (typeof cx === "number" && typeof cy === "number" && typeof w === "number" && typeof h === "number") {
+      minX = Math.min(minX, cx - w / 2);
+      maxX = Math.max(maxX, cx + w / 2);
+      minY = Math.min(minY, cy - h / 2);
+      maxY = Math.max(maxY, cy + h / 2);
+    }
+  }
+  return { minX, maxX, minY, maxY };
+}
+
+// lib/utils/autorouting/getObstaclesFromBounds.ts
+function getObstaclesFromBounds(bounds, opts = {}) {
+  const { minX, maxX, minY, maxY } = bounds;
+  const PADDING = opts.padding ?? 1;
+  if (!isFinite(minX) || !isFinite(maxX) || !isFinite(minY) || !isFinite(maxY))
+    return [];
+  const left = minX - PADDING;
+  const right = maxX + PADDING;
+  const top = maxY + PADDING;
+  const bottom = minY - PADDING;
+  const thickness = 0.01;
+  return [
+    // Top border (horizontal)
+    {
+      type: "rect",
+      layers: ["top"],
+      center: { x: (left + right) / 2, y: top },
+      width: right - left,
+      height: thickness,
+      connectedTo: []
+    },
+    // Bottom border (horizontal)
+    {
+      type: "rect",
+      layers: ["top"],
+      center: { x: (left + right) / 2, y: bottom },
+      width: right - left,
+      height: thickness,
+      connectedTo: []
+    },
+    // Left border (vertical)
+    {
+      type: "rect",
+      layers: ["top"],
+      center: { x: left, y: (top + bottom) / 2 },
+      width: thickness,
+      height: top - bottom,
+      connectedTo: []
+    },
+    // Right border (vertical)
+    {
+      type: "rect",
+      layers: ["top"],
+      center: { x: right, y: (top + bottom) / 2 },
+      width: thickness,
+      height: top - bottom,
+      connectedTo: []
+    }
+  ];
+}
+
+// lib/components/primitive-components/Trace/trace-utils/get-obstacles-for-trace.ts
+var getSchematicObstaclesForTrace = (trace) => {
+  const db = trace.root.db;
+  const connectedPorts = trace._findConnectedPorts().ports ?? [];
+  const connectedPortIds = new Set(
+    connectedPorts.map((p) => p.schematic_port_id)
+  );
+  const obstacles = [];
+  for (const elm of db.toArray()) {
+    if (elm.type === "schematic_component") {
+      const isSymbol = Boolean(elm.symbol_name);
+      const dominateAxis = elm.size.width > elm.size.height ? "horz" : "vert";
+      obstacles.push({
+        type: "rect",
+        layers: ["top"],
+        center: elm.center,
+        width: elm.size.width + (isSymbol && dominateAxis === "horz" ? -0.5 : 0),
+        height: elm.size.height + (isSymbol && dominateAxis === "vert" ? -0.5 : 0),
+        connectedTo: []
+      });
+    }
+    if (elm.type === "schematic_port") {
+      if (connectedPortIds.has(elm.schematic_port_id)) {
+        continue;
+      }
+      const dirVec = elm.facing_direction ? getUnitVectorFromDirection(elm.facing_direction) : {
+        x: 0,
+        y: 0
+      };
+      obstacles.push({
+        type: "rect",
+        layers: ["top"],
+        center: {
+          x: elm.center.x - dirVec.x * 0.1,
+          y: elm.center.y - dirVec.y * 0.1
+        },
+        width: 0.1 + Math.abs(dirVec.x) * 0.3,
+        height: 0.1 + Math.abs(dirVec.y) * 0.3,
+        connectedTo: []
+      });
+    }
+    if (elm.type === "schematic_text") {
+      obstacles.push({
+        type: "rect",
+        layers: ["top"],
+        center: elm.position,
+        width: (elm.text?.length ?? 0) * 0.1,
+        height: 0.2,
+        connectedTo: []
+      });
+    }
+    if (elm.type === "schematic_box") {
+      obstacles.push({
+        type: "rect",
+        layers: ["top"],
+        center: { x: elm.x, y: elm.y },
+        width: elm.width,
+        height: elm.height,
+        connectedTo: []
+      });
+    }
+  }
+  const bounds = getBoundsForSchematic(db.toArray());
+  obstacles.push(...getObstaclesFromBounds(bounds, { padding: 1 }));
+  return obstacles;
+};
+
+// lib/components/primitive-components/Trace/trace-utils/push-edges-of-schematic-trace-to-prevent-overlap.ts
+import { doesLineIntersectLine as doesLineIntersectLine2 } from "@tscircuit/math-utils";
+var pushEdgesOfSchematicTraceToPreventOverlap = ({
+  edges,
+  db,
+  source_trace_id
+}) => {
+  const mySourceTrace = db.source_trace.get(source_trace_id);
+  const otherEdges = getOtherSchematicTraces({
+    db,
+    source_trace_id,
+    differentNetOnly: true
+  }).flatMap((t) => t.edges);
+  const edgeOrientation = (edge) => {
+    const { from, to } = edge;
+    return from.x === to.x ? "vertical" : "horizontal";
+  };
+  for (const mySegment of edges) {
+    const mySegmentOrientation = edgeOrientation(mySegment);
+    const findOverlappingParallelSegment = () => otherEdges.find(
+      (otherEdge) => edgeOrientation(otherEdge) === mySegmentOrientation && doesLineIntersectLine2(
+        [mySegment.from, mySegment.to],
+        [otherEdge.from, otherEdge.to],
+        {
+          lineThickness: 0.05
+        }
+      )
+    );
+    let overlappingParallelSegmentFromOtherTrace = findOverlappingParallelSegment();
+    while (overlappingParallelSegmentFromOtherTrace) {
+      if (mySegmentOrientation === "horizontal") {
+        mySegment.from.y += 0.1;
+        mySegment.to.y += 0.1;
+      } else {
+        mySegment.from.x += 0.1;
+        mySegment.to.x += 0.1;
+      }
+      overlappingParallelSegmentFromOtherTrace = findOverlappingParallelSegment();
+    }
+  }
+};
+
+// lib/components/primitive-components/Trace/Trace_doInitialSchematicTraceRender.ts
+var Trace_doInitialSchematicTraceRender = (trace) => {
+  if (trace.root?.schematicDisabled) return;
+  const { db } = trace.root;
+  const { _parsedProps: props, parent } = trace;
+  if (!parent) throw new Error("Trace has no parent");
+  const { allPortsFound, portsWithSelectors: connectedPorts } = trace._findConnectedPorts();
+  const { netsWithSelectors } = trace._findConnectedNets();
+  if (!allPortsFound) return;
+  const portIds = connectedPorts.map((p) => p.port.schematic_port_id).sort();
+  const portPairKey = portIds.join(",");
+  const board = trace.root?._getBoard();
+  if (board?._connectedSchematicPortPairs) {
+    if (board._connectedSchematicPortPairs.has(portPairKey)) {
+      return;
+    }
+  }
+  const connection = {
+    name: trace.source_trace_id,
+    pointsToConnect: []
+  };
+  const obstacles = getSchematicObstaclesForTrace(trace);
+  const portsWithPosition = connectedPorts.map(({ port }) => ({
+    port,
+    position: port._getGlobalSchematicPositionAfterLayout(),
+    schematic_port_id: port.schematic_port_id ?? void 0,
+    facingDirection: port.facingDirection
+  }));
+  const isPortAndNetConnection = portsWithPosition.length === 1 && netsWithSelectors.length === 1;
+  if (isPortAndNetConnection) {
+    const net = netsWithSelectors[0].net;
+    const { port, position: anchorPos } = portsWithPosition[0];
+    let connectedNetLabel = trace.getSubcircuit().selectAll("netlabel").find((nl) => {
+      const conn = nl._parsedProps.connection ?? nl._parsedProps.connectsTo;
+      if (!conn) return false;
+      if (Array.isArray(conn)) {
+        return conn.some((selector) => {
+          const targetPort2 = trace.getSubcircuit().selectOne(selector, {
+            port: true
+          });
+          return targetPort2 === port;
+        });
+      }
+      const targetPort = trace.getSubcircuit().selectOne(conn, {
+        port: true
+      });
+      return targetPort === port;
+    });
+    if (!connectedNetLabel) {
+      const dbNetLabel = db.schematic_net_label.getWhere({
+        source_trace_id: trace.source_trace_id
+      });
+      if (dbNetLabel) {
+        connectedNetLabel = dbNetLabel;
+      }
+    }
+    if (connectedNetLabel) {
+      const labelPos = "_getGlobalSchematicPositionBeforeLayout" in connectedNetLabel ? connectedNetLabel._getGlobalSchematicPositionBeforeLayout() : connectedNetLabel.anchor_position;
+      const edges2 = [];
+      if (anchorPos.x === labelPos.x || anchorPos.y === labelPos.y) {
+        edges2.push({ from: anchorPos, to: labelPos });
+      } else {
+        edges2.push({ from: anchorPos, to: { x: labelPos.x, y: anchorPos.y } });
+        edges2.push({ from: { x: labelPos.x, y: anchorPos.y }, to: labelPos });
+      }
+      const dbTrace2 = db.schematic_trace.insert({
+        source_trace_id: trace.source_trace_id,
+        edges: edges2,
+        junctions: []
+      });
+      trace.schematic_trace_id = dbTrace2.schematic_trace_id;
+      return;
+    }
+    if (trace.props.schDisplayLabel) {
+      const side2 = getEnteringEdgeFromDirection(port.facingDirection) ?? "bottom";
+      db.schematic_net_label.insert({
+        text: trace.props.schDisplayLabel,
+        source_net_id: net.source_net_id,
+        anchor_position: anchorPos,
+        center: computeSchematicNetLabelCenter({
+          anchor_position: anchorPos,
+          anchor_side: side2,
+          text: trace.props.schDisplayLabel
+        }),
+        anchor_side: side2
+      });
+      return;
+    }
+    const side = getEnteringEdgeFromDirection(port.facingDirection) ?? "bottom";
+    const netLabel = db.schematic_net_label.insert({
+      text: net._parsedProps.name,
+      source_net_id: net.source_net_id,
+      anchor_position: anchorPos,
+      center: computeSchematicNetLabelCenter({
+        anchor_position: anchorPos,
+        anchor_side: side,
+        text: net._parsedProps.name
+      }),
+      anchor_side: side
+    });
+    return;
+  }
+  if (trace.props.schDisplayLabel) {
+    if ("from" in trace.props && "to" in trace.props || "path" in trace.props) {
+      trace._doInitialSchematicTraceRenderWithDisplayLabel();
+      return;
+    }
+  }
+  if (portsWithPosition.length < 2) {
+    return;
+  }
+  connection.pointsToConnect = portsWithPosition.map(({ position }) => ({
+    ...position,
+    layer: "top"
+  }));
+  const bounds = computeObstacleBounds(obstacles);
+  const BOUNDS_MARGIN = 2;
+  const simpleRouteJsonInput = {
+    minTraceWidth: 0.1,
+    obstacles,
+    connections: [connection],
+    bounds: {
+      minX: bounds.minX - BOUNDS_MARGIN,
+      maxX: bounds.maxX + BOUNDS_MARGIN,
+      minY: bounds.minY - BOUNDS_MARGIN,
+      maxY: bounds.maxY + BOUNDS_MARGIN
+    },
+    layerCount: 1
+  };
+  let Autorouter = MultilayerIjump;
+  let skipOtherTraceInteraction = false;
+  if (trace.getSubcircuit().props._schDirectLineRoutingEnabled) {
+    Autorouter = DirectLineRouter;
+    skipOtherTraceInteraction = true;
+  }
+  const autorouter = new Autorouter({
+    input: simpleRouteJsonInput,
+    MAX_ITERATIONS: 100,
+    OBSTACLE_MARGIN: 0.1,
+    isRemovePathLoopsEnabled: true,
+    isShortenPathWithShortcutsEnabled: true,
+    marginsWithCosts: [
+      {
+        margin: 1,
+        enterCost: 0,
+        travelCostFactor: 1
+      },
+      {
+        margin: 0.3,
+        enterCost: 0,
+        travelCostFactor: 1
+      },
+      {
+        margin: 0.2,
+        enterCost: 0,
+        travelCostFactor: 2
+      },
+      {
+        margin: 0.1,
+        enterCost: 0,
+        travelCostFactor: 3
+      }
+    ]
+  });
+  let results = autorouter.solveAndMapToTraces();
+  if (results.length === 0) {
+    if (trace._isSymbolToChipConnection() || trace._isSymbolToSymbolConnection() || trace._isChipToChipConnection()) {
+      trace._doInitialSchematicTraceRenderWithDisplayLabel();
+      return;
+    }
+    const directLineRouter = new DirectLineRouter({
+      input: simpleRouteJsonInput
+    });
+    results = directLineRouter.solveAndMapToTraces();
+    skipOtherTraceInteraction = true;
+  }
+  const [{ route }] = results;
+  let edges = [];
+  for (let i = 0; i < route.length - 1; i++) {
+    edges.push({
+      from: route[i],
+      to: route[i + 1]
+    });
+  }
+  const source_trace_id = trace.source_trace_id;
+  let junctions = [];
+  if (!skipOtherTraceInteraction) {
+    pushEdgesOfSchematicTraceToPreventOverlap({ edges, db, source_trace_id });
+    const otherEdges = getOtherSchematicTraces({
+      db,
+      source_trace_id,
+      differentNetOnly: true
+    }).flatMap((t) => t.edges);
+    edges = createSchematicTraceCrossingSegments({ edges, otherEdges });
+    junctions = createSchematicTraceJunctions({
+      edges,
+      db,
+      source_trace_id: trace.source_trace_id
+    });
+  }
+  const lastEdge = edges[edges.length - 1];
+  const lastEdgePort = portsWithPosition[portsWithPosition.length - 1];
+  const lastDominantDirection = getDominantDirection(lastEdge);
+  edges.push(...getStubEdges({ lastEdge, lastEdgePort, lastDominantDirection }));
+  const firstEdge = edges[0];
+  const firstEdgePort = portsWithPosition[0];
+  const firstDominantDirection = getDominantDirection(firstEdge);
+  edges.unshift(
+    ...getStubEdges({
+      firstEdge,
+      firstEdgePort,
+      firstDominantDirection
+    })
+  );
+  if (!trace.source_trace_id) {
+    throw new Error("Missing source_trace_id for schematic trace insertion.");
+  }
+  if (trace.getSubcircuit()._parsedProps.schTraceAutoLabelEnabled && countComplexElements(junctions, edges) >= 5 && (trace._isSymbolToChipConnection() || trace._isSymbolToSymbolConnection() || trace._isChipToChipConnection())) {
+    trace._doInitialSchematicTraceRenderWithDisplayLabel();
+    return;
+  }
+  const dbTrace = db.schematic_trace.insert({
+    source_trace_id: trace.source_trace_id,
+    edges,
+    junctions
+  });
+  trace.schematic_trace_id = dbTrace.schematic_trace_id;
+  if (board?._connectedSchematicPortPairs)
+    board._connectedSchematicPortPairs.add(portPairKey);
+};
+
+// lib/components/primitive-components/Trace/Trace_doInitialPcbTraceRender.ts
+import { MultilayerIjump as MultilayerIjump2 } from "@tscircuit/infgrid-ijump-astar";
+import "circuit-json";
+import { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectivity-map";
+
+// lib/components/primitive-components/Trace/trace-utils/compute-trace-length.ts
+function getTraceLength(route) {
+  let totalLength = 0;
+  for (let i = 0; i < route.length; i++) {
+    const point = route[i];
+    if (point.route_type === "wire") {
+      const nextPoint = route[i + 1];
+      if (nextPoint) {
+        const dx = nextPoint.x - point.x;
+        const dy = nextPoint.y - point.y;
+        totalLength += Math.sqrt(dx * dx + dy * dy);
+      }
+    } else if (point.route_type === "via") {
+      totalLength += 1.6;
+    }
+  }
+  return totalLength;
+}
+
+// lib/components/primitive-components/Trace/Trace_doInitialPcbTraceRender.ts
+var portToObjective = (port) => {
+  const portPosition = port._getGlobalPcbPositionAfterLayout();
+  return {
+    ...portPosition,
+    layers: port.getAvailablePcbLayers()
+  };
+};
+var SHOULD_USE_SINGLE_LAYER_ROUTING = false;
+function Trace_doInitialPcbTraceRender(trace) {
+  if (trace.root?.pcbDisabled) return;
+  const { db } = trace.root;
+  const { _parsedProps: props, parent } = trace;
+  const subcircuit = trace.getSubcircuit();
+  if (!parent) throw new Error("Trace has no parent");
+  if (subcircuit._parsedProps.routingDisabled) {
+    return;
+  }
+  const cachedRoute = subcircuit._parsedProps.pcbRouteCache?.pcbTraces;
+  if (cachedRoute) {
+    const pcb_trace2 = db.pcb_trace.insert({
+      route: cachedRoute.flatMap((trace2) => trace2.route),
+      source_trace_id: trace.source_trace_id,
+      subcircuit_id: subcircuit?.subcircuit_id ?? void 0,
+      pcb_group_id: trace.getGroup()?.pcb_group_id ?? void 0
+    });
+    trace.pcb_trace_id = pcb_trace2.pcb_trace_id;
+    return;
+  }
+  if (!subcircuit._shouldUseTraceByTraceRouting()) {
+    return;
+  }
+  const { allPortsFound, ports } = trace._findConnectedPorts();
+  const portsConnectedOnPcbViaNet = [];
+  if (!allPortsFound) return;
+  const portsWithoutMatchedPcbPrimitive = [];
+  for (const port of ports) {
+    if (!port._hasMatchedPcbPrimitive()) {
+      portsWithoutMatchedPcbPrimitive.push(port);
+    }
+  }
+  if (portsWithoutMatchedPcbPrimitive.length > 0) {
+    db.pcb_trace_error.insert({
+      error_type: "pcb_trace_error",
+      source_trace_id: trace.source_trace_id,
+      message: `Some ports did not have a matching PCB primitive (e.g. a pad or plated hole), this can happen if a footprint is missing. As a result, ${trace} wasn't routed. Missing ports: ${portsWithoutMatchedPcbPrimitive.map((p) => p.getString()).join(", ")}`,
+      pcb_trace_id: trace.pcb_trace_id,
+      pcb_component_ids: [],
+      pcb_port_ids: portsWithoutMatchedPcbPrimitive.map((p) => p.pcb_port_id).filter(Boolean)
+    });
+    return;
+  }
+  const nets = trace._findConnectedNets().netsWithSelectors;
+  if (ports.length === 0 && nets.length === 2) {
+    trace.renderError(
+      `Trace connects two nets, we haven't implemented a way to route this yet`
+    );
+    return;
+  } else if (ports.length === 1 && nets.length === 1) {
+    const port = ports[0];
+    const portsInNet = nets[0].net.getAllConnectedPorts();
+    const otherPortsInNet = portsInNet.filter((p) => p !== port);
+    if (otherPortsInNet.length === 0) {
+      console.log(
+        "Nothing to connect this port to, the net is empty. TODO should emit a warning!"
+      );
+      return;
+    }
+    const closestPortInNet = getClosest(port, otherPortsInNet);
+    portsConnectedOnPcbViaNet.push(closestPortInNet);
+    ports.push(closestPortInNet);
+  } else if (ports.length > 1 && nets.length >= 1) {
+    trace.renderError(
+      `Trace has more than one port and one or more nets, we don't currently support this type of complex trace routing`
+    );
+    return;
+  }
+  const hints = ports.flatMap(
+    (port) => port.matchedComponents.filter((c) => c.componentName === "TraceHint")
+  );
+  const pcbRouteHints = (trace._parsedProps.pcbRouteHints ?? []).concat(
+    hints.flatMap((h) => h.getPcbRouteHints())
+  );
+  if (ports.length > 2) {
+    trace.renderError(
+      `Trace has more than two ports (${ports.map((p) => p.getString()).join(
+        ", "
+      )}), routing between more than two ports for a single trace is not implemented`
+    );
+    return;
+  }
+  const alreadyRoutedTraces = trace.getSubcircuit().selectAll("trace").filter(
+    (trace2) => trace2.renderPhaseStates.PcbTraceRender.initialized
+  );
+  const isAlreadyRouted = alreadyRoutedTraces.some(
+    (trace2) => trace2._portsRoutedOnPcb.length === ports.length && trace2._portsRoutedOnPcb.every(
+      (portRoutedByOtherTrace) => ports.includes(portRoutedByOtherTrace)
+    )
+  );
+  if (isAlreadyRouted) {
+    return;
+  }
+  let orderedRouteObjectives = [];
+  if (pcbRouteHints.length === 0) {
+    orderedRouteObjectives = [
+      portToObjective(ports[0]),
+      portToObjective(ports[1])
+    ];
+  } else {
+    orderedRouteObjectives = [
+      portToObjective(ports[0]),
+      ...pcbRouteHints,
+      portToObjective(ports[1])
+    ];
+  }
+  const candidateLayerCombinations = findPossibleTraceLayerCombinations(
+    orderedRouteObjectives
+  );
+  if (SHOULD_USE_SINGLE_LAYER_ROUTING && candidateLayerCombinations.length === 0) {
+    trace.renderError(
+      `Could not find a common layer (using hints) for trace ${trace.getString()}`
+    );
+    return;
+  }
+  const connMap = getFullConnectivityMapFromCircuitJson(
+    trace.root.db.toArray()
+  );
+  const [obstacles, errGettingObstacles] = tryNow(
+    () => getObstaclesFromCircuitJson(trace.root.db.toArray())
+    // Remove as any when autorouting-dataset gets updated
+  );
+  if (errGettingObstacles) {
+    trace.renderError({
+      type: "pcb_trace_error",
+      error_type: "pcb_trace_error",
+      pcb_trace_error_id: trace.pcb_trace_id,
+      message: `Error getting obstacles for autorouting: ${errGettingObstacles.message}`,
+      source_trace_id: trace.source_trace_id,
+      center: { x: 0, y: 0 },
+      pcb_port_ids: ports.map((p) => p.pcb_port_id),
+      pcb_trace_id: trace.pcb_trace_id,
+      pcb_component_ids: []
+    });
+    return;
+  }
+  for (const obstacle of obstacles) {
+    const connectedTo = obstacle.connectedTo;
+    if (connectedTo.length > 0) {
+      const netId = connMap.getNetConnectedToId(obstacle.connectedTo[0]);
+      if (netId) {
+        obstacle.connectedTo.push(netId);
+      }
+    }
+  }
+  let orderedRoutePoints = [];
+  if (candidateLayerCombinations.length === 0) {
+    orderedRoutePoints = orderedRouteObjectives;
+  } else {
+    const candidateLayerSelections = candidateLayerCombinations[0].layer_path;
+    orderedRoutePoints = orderedRouteObjectives.map((t, idx) => {
+      if (t.via) {
+        return {
+          ...t,
+          via_to_layer: candidateLayerSelections[idx]
+        };
+      }
+      return { ...t, layers: [candidateLayerSelections[idx]] };
+    });
+  }
+  ;
+  orderedRoutePoints[0].pcb_port_id = ports[0].pcb_port_id;
+  orderedRoutePoints[orderedRoutePoints.length - 1].pcb_port_id = ports[1].pcb_port_id;
+  const routes = [];
+  for (const [a, b] of pairs(orderedRoutePoints)) {
+    const dominantLayer = "via_to_layer" in a ? a.via_to_layer : null;
+    const BOUNDS_MARGIN = 2;
+    const aLayer = "layers" in a && a.layers.length === 1 ? a.layers[0] : dominantLayer ?? "top";
+    const bLayer = "layers" in b && b.layers.length === 1 ? b.layers[0] : dominantLayer ?? "top";
+    const pcbPortA = "pcb_port_id" in a ? a.pcb_port_id : null;
+    const pcbPortB = "pcb_port_id" in b ? b.pcb_port_id : null;
+    const minTraceWidth = trace.getSubcircuit()._parsedProps.minTraceWidth ?? 0.16;
+    const ijump = new MultilayerIjump2({
+      OBSTACLE_MARGIN: minTraceWidth * 2,
+      isRemovePathLoopsEnabled: true,
+      optimizeWithGoalBoxes: Boolean(pcbPortA && pcbPortB),
+      connMap,
+      input: {
+        obstacles,
+        minTraceWidth,
+        connections: [
+          {
+            name: trace.source_trace_id,
+            pointsToConnect: [
+              { ...a, layer: aLayer, pcb_port_id: pcbPortA },
+              { ...b, layer: bLayer, pcb_port_id: pcbPortB }
+            ]
+          }
+        ],
+        layerCount: 2,
+        bounds: {
+          minX: Math.min(a.x, b.x) - BOUNDS_MARGIN,
+          maxX: Math.max(a.x, b.x) + BOUNDS_MARGIN,
+          minY: Math.min(a.y, b.y) - BOUNDS_MARGIN,
+          maxY: Math.max(a.y, b.y) + BOUNDS_MARGIN
+        }
+      }
+    });
+    let traces = null;
+    try {
+      traces = ijump.solveAndMapToTraces();
+    } catch (e) {
+      trace.renderError({
+        type: "pcb_trace_error",
+        pcb_trace_error_id: trace.source_trace_id,
+        error_type: "pcb_trace_error",
+        message: `error solving route: ${e.message}`,
+        source_trace_id: trace.pcb_trace_id,
+        center: { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 },
+        pcb_port_ids: ports.map((p) => p.pcb_port_id),
+        pcb_trace_id: trace.pcb_trace_id,
+        pcb_component_ids: ports.map((p) => p.pcb_component_id)
+      });
+    }
+    if (!traces) return;
+    if (traces.length === 0) {
+      trace.renderError({
+        type: "pcb_trace_error",
+        error_type: "pcb_trace_error",
+        pcb_trace_error_id: trace.pcb_trace_id,
+        message: `Could not find a route for ${trace}`,
+        source_trace_id: trace.source_trace_id,
+        center: { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 },
+        pcb_port_ids: ports.map((p) => p.pcb_port_id),
+        pcb_trace_id: trace.pcb_trace_id,
+        pcb_component_ids: ports.map((p) => p.pcb_component_id)
+      });
+      return;
+    }
+    const [autoroutedTrace] = traces;
+    if (dominantLayer) {
+      autoroutedTrace.route = autoroutedTrace.route.map((p) => {
+        if (p.route_type === "wire" && !p.layer) {
+          p.layer = dominantLayer;
+        }
+        return p;
+      });
+    }
+    if (pcbPortA && autoroutedTrace.route[0].route_type === "wire") {
+      autoroutedTrace.route[0].start_pcb_port_id = pcbPortA;
+    }
+    const lastRoutePoint = autoroutedTrace.route[autoroutedTrace.route.length - 1];
+    if (pcbPortB && lastRoutePoint.route_type === "wire") {
+      lastRoutePoint.end_pcb_port_id = pcbPortB;
+    }
+    routes.push(autoroutedTrace.route);
+  }
+  const mergedRoute = mergeRoutes(routes);
+  const traceLength = getTraceLength(mergedRoute);
+  const pcb_trace = db.pcb_trace.insert({
+    route: mergedRoute,
+    source_trace_id: trace.source_trace_id,
+    subcircuit_id: trace.getSubcircuit()?.subcircuit_id,
+    trace_length: traceLength
+  });
+  trace._portsRoutedOnPcb = ports;
+  trace.pcb_trace_id = pcb_trace.pcb_trace_id;
+  for (const point of mergedRoute) {
+    if (point.route_type === "via") {
+      db.pcb_via.insert({
+        pcb_trace_id: pcb_trace.pcb_trace_id,
+        x: point.x,
+        y: point.y,
+        hole_diameter: 0.3,
+        outer_diameter: 0.6,
+        layers: [point.from_layer, point.to_layer],
+        from_layer: point.from_layer,
+        to_layer: point.to_layer
+      });
+    }
+  }
+  trace._insertErrorIfTraceIsOutsideBoard(mergedRoute, ports);
+}
+
+// lib/components/primitive-components/Trace/Trace__doInitialSchematicTraceRenderWithDisplayLabel.ts
+function Trace__doInitialSchematicTraceRenderWithDisplayLabel(trace) {
+  if (trace.root?.schematicDisabled) return;
+  const { db } = trace.root;
+  const { _parsedProps: props, parent } = trace;
+  if (!parent) throw new Error("Trace has no parent");
+  const { allPortsFound, portsWithSelectors: connectedPorts } = trace._findConnectedPorts();
+  if (!allPortsFound) return;
+  const portsWithPosition = connectedPorts.map(({ port }) => ({
+    port,
+    position: port._getGlobalSchematicPositionAfterLayout(),
+    schematic_port_id: port.schematic_port_id,
+    facingDirection: port.facingDirection
+  }));
+  if (portsWithPosition.length < 2) {
+    throw new Error("Expected at least two ports in portsWithPosition.");
+  }
+  let fromPortName;
+  let toPortName;
+  const fromAnchorPos = portsWithPosition[0].position;
+  const fromPort = portsWithPosition[0].port;
+  if ("path" in trace.props) {
+    if (trace.props.path.length !== 2) {
+      throw new Error("Invalid 'path': Must contain exactly two elements.");
+    }
+    ;
+    [fromPortName, toPortName] = trace.props.path;
+  } else {
+    if (!("from" in trace.props && "to" in trace.props)) {
+      throw new Error("Missing 'from' or 'to' properties in props.");
+    }
+    fromPortName = trace.props.from;
+    toPortName = trace.props.to;
+  }
+  if (!fromPort.source_port_id) {
+    throw new Error(
+      `Missing source_port_id for the 'from' port (${fromPortName}).`
+    );
+  }
+  const toAnchorPos = portsWithPosition[1].position;
+  const toPort = portsWithPosition[1].port;
+  if (!toPort.source_port_id) {
+    throw new Error(`Missing source_port_id for the 'to' port (${toPortName}).`);
+  }
+  const existingFromNetLabel = db.schematic_net_label.list().find((label) => label.source_net_id === fromPort.source_port_id);
+  const existingToNetLabel = db.schematic_net_label.list().find((label) => label.source_net_id === toPort.source_port_id);
+  const [firstPort, secondPort] = connectedPorts.map(({ port }) => port);
+  const isFirstPortSchematicBox = firstPort.parent?.config.shouldRenderAsSchematicBox;
+  const pinFullName = isFirstPortSchematicBox ? `${firstPort?.parent?.props.name}_${firstPort?.props.name}` : `${secondPort?.parent?.props.name}_${secondPort?.props.name}`;
+  const netLabelText = trace.props.schDisplayLabel ?? pinFullName;
+  if (existingFromNetLabel && existingFromNetLabel.text !== netLabelText) {
+    existingFromNetLabel.text = `${netLabelText} / ${existingFromNetLabel.text}`;
+  }
+  if (existingToNetLabel && existingToNetLabel?.text !== netLabelText) {
+    existingToNetLabel.text = `${netLabelText} / ${existingToNetLabel.text}`;
+  }
+  if (!existingToNetLabel) {
+    const toSide = getEnteringEdgeFromDirection(toPort.facingDirection) ?? "bottom";
+    db.schematic_net_label.insert({
+      text: trace.props.schDisplayLabel ?? pinFullName,
+      source_net_id: toPort.source_port_id,
+      anchor_position: toAnchorPos,
+      center: computeSchematicNetLabelCenter({
+        anchor_position: toAnchorPos,
+        anchor_side: toSide,
+        text: trace.props.schDisplayLabel ?? pinFullName
+      }),
+      anchor_side: toSide
+    });
+  }
+  if (!existingFromNetLabel) {
+    const fromSide = getEnteringEdgeFromDirection(fromPort.facingDirection) ?? "bottom";
+    db.schematic_net_label.insert({
+      text: trace.props.schDisplayLabel ?? pinFullName,
+      source_net_id: fromPort.source_port_id,
+      anchor_position: fromAnchorPos,
+      center: computeSchematicNetLabelCenter({
+        anchor_position: fromAnchorPos,
+        anchor_side: fromSide,
+        text: trace.props.schDisplayLabel ?? pinFullName
+      }),
+      anchor_side: fromSide
+    });
+  }
+}
+
+// lib/components/primitive-components/Trace/Trace__findConnectedPorts.ts
+function Trace__findConnectedPorts(trace) {
+  const { db } = trace.root;
+  const { _parsedProps: props, parent } = trace;
+  if (!parent) throw new Error("Trace has no parent");
+  const portSelectors = trace.getTracePortPathSelectors();
+  const portsWithSelectors = portSelectors.map((selector) => ({
+    selector,
+    port: trace.getSubcircuit().selectOne(selector, { type: "port" }) ?? null
+  }));
+  for (const { selector, port } of portsWithSelectors) {
+    if (!port) {
+      let parentSelector;
+      let portToken;
+      const dotIndex = selector.lastIndexOf(".");
+      if (dotIndex !== -1 && dotIndex > selector.lastIndexOf(" ")) {
+        parentSelector = selector.slice(0, dotIndex);
+        portToken = selector.slice(dotIndex + 1);
+      } else {
+        const match = selector.match(/^(.*[ >])?([^ >]+)$/);
+        parentSelector = match?.[1]?.trim() ?? "";
+        portToken = match?.[2] ?? selector;
+      }
+      let targetComponent = parentSelector ? trace.getSubcircuit().selectOne(parentSelector) : null;
+      if (!targetComponent && parentSelector && !/[.#\[]/.test(parentSelector)) {
+        targetComponent = trace.getSubcircuit().selectOne(`.${parentSelector}`);
+      }
+      if (!targetComponent) {
+        if (parentSelector) {
+          trace.renderError(
+            `Could not find port for selector "${selector}". Component "${parentSelector}" not found`
+          );
+        } else {
+          trace.renderError(`Could not find port for selector "${selector}"`);
+        }
+      } else {
+        const ports = targetComponent.children.filter(
+          (c) => c.componentName === "Port"
+        );
+        const portLabel = portToken.includes(".") ? portToken.split(".").pop() ?? "" : portToken;
+        const portNames = ports.flatMap((c) => c.getNameAndAliases());
+        const hasCustomLabels = portNames.some((n) => !/^(pin\d+|\d+)$/.test(n));
+        const labelList = Array.from(new Set(portNames)).join(", ");
+        let detail;
+        if (ports.length === 0) {
+          detail = "It has no ports";
+        } else if (!hasCustomLabels) {
+          detail = `It has ${ports.length} pins and no pinLabels (consider adding pinLabels)`;
+        } else {
+          detail = `It has [${labelList}]`;
+        }
+        trace.renderError(
+          `Could not find port for selector "${selector}". Component "${targetComponent.props.name ?? parentSelector}" found, but does not have pin "${portLabel}". ${detail}`
+        );
+      }
+    }
+  }
+  if (portsWithSelectors.some((p) => !p.port)) {
+    return { allPortsFound: false };
+  }
+  return {
+    allPortsFound: true,
+    portsWithSelectors,
+    ports: portsWithSelectors.map(({ port }) => port)
+  };
+}
+
+// lib/components/primitive-components/Trace/Trace.ts
+var Trace3 = class extends PrimitiveComponent2 {
+  source_trace_id = null;
+  pcb_trace_id = null;
+  schematic_trace_id = null;
+  _portsRoutedOnPcb;
+  subcircuit_connectivity_map_key = null;
+  _traceConnectionHash = null;
+  constructor(props) {
+    super(props);
+    this._portsRoutedOnPcb = [];
+  }
+  get config() {
+    return {
+      zodProps: traceProps,
+      componentName: "Trace"
+    };
+  }
+  _getTracePortOrNetSelectorListFromProps() {
+    if ("from" in this.props && "to" in this.props) {
+      return [
+        typeof this.props.from === "string" ? this.props.from : this.props.from.getPortSelector(),
+        typeof this.props.to === "string" ? this.props.to : this.props.to.getPortSelector()
+      ];
+    }
+    if ("path" in this.props) {
+      return this.props.path.map(
+        (p) => typeof p === "string" ? p : p.getPortSelector()
+      );
     }
-    return {
-      allPortsFound: true,
-      portsWithSelectors,
-      ports: portsWithSelectors.map(({ port }) => port)
-    };
+    return [];
+  }
+  getTracePortPathSelectors() {
+    return this._getTracePortOrNetSelectorListFromProps().filter(
+      (selector) => !selector.includes("net.")
+    );
+  }
+  getTracePathNetSelectors() {
+    return this._getTracePortOrNetSelectorListFromProps().filter(
+      (selector) => selector.includes("net.")
+    );
+  }
+  _findConnectedPorts() {
+    return Trace__findConnectedPorts(this);
   }
   _resolveNet(selector) {
     const direct = this.getSubcircuit().selectOne(selector, {
@@ -4997,363 +5601,10 @@ var Trace2 = class extends PrimitiveComponent2 {
     }
   }
   doInitialPcbTraceRender() {
-    if (this.root?.pcbDisabled) return;
-    const { db } = this.root;
-    const { _parsedProps: props, parent } = this;
-    const subcircuit = this.getSubcircuit();
-    if (!parent) throw new Error("Trace has no parent");
-    if (subcircuit._parsedProps.routingDisabled) {
-      return;
-    }
-    const cachedRoute = subcircuit._parsedProps.pcbRouteCache?.pcbTraces;
-    if (cachedRoute) {
-      const pcb_trace2 = db.pcb_trace.insert({
-        route: cachedRoute.flatMap((trace) => trace.route),
-        source_trace_id: this.source_trace_id,
-        subcircuit_id: subcircuit?.subcircuit_id ?? void 0,
-        pcb_group_id: this.getGroup()?.pcb_group_id ?? void 0
-      });
-      this.pcb_trace_id = pcb_trace2.pcb_trace_id;
-      return;
-    }
-    if (!subcircuit._shouldUseTraceByTraceRouting()) {
-      return;
-    }
-    const { allPortsFound, ports } = this._findConnectedPorts();
-    const portsConnectedOnPcbViaNet = [];
-    if (!allPortsFound) return;
-    const portsWithoutMatchedPcbPrimitive = [];
-    for (const port of ports) {
-      if (!port._hasMatchedPcbPrimitive()) {
-        portsWithoutMatchedPcbPrimitive.push(port);
-      }
-    }
-    if (portsWithoutMatchedPcbPrimitive.length > 0) {
-      db.pcb_trace_error.insert({
-        error_type: "pcb_trace_error",
-        source_trace_id: this.source_trace_id,
-        message: `Some ports did not have a matching PCB primitive (e.g. a pad or plated hole), this can happen if a footprint is missing. As a result, ${this} wasn't routed. Missing ports: ${portsWithoutMatchedPcbPrimitive.map((p) => p.getString()).join(", ")}`,
-        pcb_trace_id: this.pcb_trace_id,
-        pcb_component_ids: [],
-        pcb_port_ids: portsWithoutMatchedPcbPrimitive.map((p) => p.pcb_port_id).filter(Boolean)
-      });
-      return;
-    }
-    const nets = this._findConnectedNets().netsWithSelectors;
-    if (ports.length === 0 && nets.length === 2) {
-      this.renderError(
-        `Trace connects two nets, we haven't implemented a way to route this yet`
-      );
-      return;
-    } else if (ports.length === 1 && nets.length === 1) {
-      const port = ports[0];
-      const portsInNet = nets[0].net.getAllConnectedPorts();
-      const otherPortsInNet = portsInNet.filter((p) => p !== port);
-      if (otherPortsInNet.length === 0) {
-        console.log(
-          "Nothing to connect this port to, the net is empty. TODO should emit a warning!"
-        );
-        return;
-      }
-      const closestPortInNet = getClosest(port, otherPortsInNet);
-      portsConnectedOnPcbViaNet.push(closestPortInNet);
-      ports.push(closestPortInNet);
-    } else if (ports.length > 1 && nets.length >= 1) {
-      this.renderError(
-        `Trace has more than one port and one or more nets, we don't currently support this type of complex trace routing`
-      );
-      return;
-    }
-    const hints = ports.flatMap(
-      (port) => port.matchedComponents.filter((c) => c.componentName === "TraceHint")
-    );
-    const pcbRouteHints = (this._parsedProps.pcbRouteHints ?? []).concat(
-      hints.flatMap((h) => h.getPcbRouteHints())
-    );
-    if (ports.length > 2) {
-      this.renderError(
-        `Trace has more than two ports (${ports.map((p) => p.getString()).join(
-          ", "
-        )}), routing between more than two ports for a single trace is not implemented`
-      );
-      return;
-    }
-    const alreadyRoutedTraces = this.getSubcircuit().selectAll("trace").filter(
-      (trace) => trace.renderPhaseStates.PcbTraceRender.initialized
-    );
-    const isAlreadyRouted = alreadyRoutedTraces.some(
-      (trace) => trace._portsRoutedOnPcb.length === ports.length && trace._portsRoutedOnPcb.every(
-        (portRoutedByOtherTrace) => ports.includes(portRoutedByOtherTrace)
-      )
-    );
-    if (isAlreadyRouted) {
-      return;
-    }
-    let orderedRouteObjectives = [];
-    if (pcbRouteHints.length === 0) {
-      orderedRouteObjectives = [
-        portToObjective(ports[0]),
-        portToObjective(ports[1])
-      ];
-    } else {
-      orderedRouteObjectives = [
-        portToObjective(ports[0]),
-        ...pcbRouteHints,
-        portToObjective(ports[1])
-      ];
-    }
-    const candidateLayerCombinations = findPossibleTraceLayerCombinations(
-      orderedRouteObjectives
-    );
-    if (SHOULD_USE_SINGLE_LAYER_ROUTING && candidateLayerCombinations.length === 0) {
-      this.renderError(
-        `Could not find a common layer (using hints) for trace ${this.getString()}`
-      );
-      return;
-    }
-    const connMap = getFullConnectivityMapFromCircuitJson(
-      this.root.db.toArray()
-    );
-    const [obstacles, errGettingObstacles] = tryNow(
-      () => getObstaclesFromCircuitJson(this.root.db.toArray())
-      // Remove as any when autorouting-dataset gets updated
-    );
-    if (errGettingObstacles) {
-      this.renderError({
-        type: "pcb_trace_error",
-        error_type: "pcb_trace_error",
-        pcb_trace_error_id: this.pcb_trace_id,
-        message: `Error getting obstacles for autorouting: ${errGettingObstacles.message}`,
-        source_trace_id: this.source_trace_id,
-        center: { x: 0, y: 0 },
-        pcb_port_ids: ports.map((p) => p.pcb_port_id),
-        pcb_trace_id: this.pcb_trace_id,
-        pcb_component_ids: []
-      });
-      return;
-    }
-    for (const obstacle of obstacles) {
-      const connectedTo = obstacle.connectedTo;
-      if (connectedTo.length > 0) {
-        const netId = connMap.getNetConnectedToId(obstacle.connectedTo[0]);
-        if (netId) {
-          obstacle.connectedTo.push(netId);
-        }
-      }
-    }
-    let orderedRoutePoints = [];
-    if (candidateLayerCombinations.length === 0) {
-      orderedRoutePoints = orderedRouteObjectives;
-    } else {
-      const candidateLayerSelections = candidateLayerCombinations[0].layer_path;
-      orderedRoutePoints = orderedRouteObjectives.map((t, idx) => {
-        if (t.via) {
-          return {
-            ...t,
-            via_to_layer: candidateLayerSelections[idx]
-          };
-        }
-        return { ...t, layers: [candidateLayerSelections[idx]] };
-      });
-    }
-    ;
-    orderedRoutePoints[0].pcb_port_id = ports[0].pcb_port_id;
-    orderedRoutePoints[orderedRoutePoints.length - 1].pcb_port_id = ports[1].pcb_port_id;
-    const routes = [];
-    for (const [a, b] of pairs(orderedRoutePoints)) {
-      const dominantLayer = "via_to_layer" in a ? a.via_to_layer : null;
-      const BOUNDS_MARGIN = 2;
-      const aLayer = "layers" in a && a.layers.length === 1 ? a.layers[0] : dominantLayer ?? "top";
-      const bLayer = "layers" in b && b.layers.length === 1 ? b.layers[0] : dominantLayer ?? "top";
-      const pcbPortA = "pcb_port_id" in a ? a.pcb_port_id : null;
-      const pcbPortB = "pcb_port_id" in b ? b.pcb_port_id : null;
-      const minTraceWidth = this.getSubcircuit()._parsedProps.minTraceWidth ?? 0.16;
-      const ijump = new MultilayerIjump({
-        OBSTACLE_MARGIN: minTraceWidth * 2,
-        isRemovePathLoopsEnabled: true,
-        optimizeWithGoalBoxes: Boolean(pcbPortA && pcbPortB),
-        connMap,
-        input: {
-          obstacles,
-          minTraceWidth,
-          connections: [
-            {
-              name: this.source_trace_id,
-              pointsToConnect: [
-                { ...a, layer: aLayer, pcb_port_id: pcbPortA },
-                { ...b, layer: bLayer, pcb_port_id: pcbPortB }
-              ]
-            }
-          ],
-          layerCount: 2,
-          bounds: {
-            minX: Math.min(a.x, b.x) - BOUNDS_MARGIN,
-            maxX: Math.max(a.x, b.x) + BOUNDS_MARGIN,
-            minY: Math.min(a.y, b.y) - BOUNDS_MARGIN,
-            maxY: Math.max(a.y, b.y) + BOUNDS_MARGIN
-          }
-        }
-      });
-      let traces = null;
-      try {
-        traces = ijump.solveAndMapToTraces();
-      } catch (e) {
-        this.renderError({
-          type: "pcb_trace_error",
-          pcb_trace_error_id: this.source_trace_id,
-          error_type: "pcb_trace_error",
-          message: `error solving route: ${e.message}`,
-          source_trace_id: this.pcb_trace_id,
-          center: { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 },
-          pcb_port_ids: ports.map((p) => p.pcb_port_id),
-          pcb_trace_id: this.pcb_trace_id,
-          pcb_component_ids: ports.map((p) => p.pcb_component_id)
-        });
-      }
-      if (!traces) return;
-      if (traces.length === 0) {
-        this.renderError({
-          type: "pcb_trace_error",
-          error_type: "pcb_trace_error",
-          pcb_trace_error_id: this.pcb_trace_id,
-          message: `Could not find a route for ${this}`,
-          source_trace_id: this.source_trace_id,
-          center: { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 },
-          pcb_port_ids: ports.map((p) => p.pcb_port_id),
-          pcb_trace_id: this.pcb_trace_id,
-          pcb_component_ids: ports.map((p) => p.pcb_component_id)
-        });
-        return;
-      }
-      const [trace] = traces;
-      if (dominantLayer) {
-        trace.route = trace.route.map((p) => {
-          if (p.route_type === "wire" && !p.layer) {
-            p.layer = dominantLayer;
-          }
-          return p;
-        });
-      }
-      if (pcbPortA && trace.route[0].route_type === "wire") {
-        trace.route[0].start_pcb_port_id = pcbPortA;
-      }
-      const lastRoutePoint = trace.route[trace.route.length - 1];
-      if (pcbPortB && lastRoutePoint.route_type === "wire") {
-        lastRoutePoint.end_pcb_port_id = pcbPortB;
-      }
-      routes.push(trace.route);
-    }
-    const mergedRoute = mergeRoutes(routes);
-    const traceLength = getTraceLength(mergedRoute);
-    const pcb_trace = db.pcb_trace.insert({
-      route: mergedRoute,
-      source_trace_id: this.source_trace_id,
-      subcircuit_id: this.getSubcircuit()?.subcircuit_id,
-      trace_length: traceLength
-    });
-    this._portsRoutedOnPcb = ports;
-    this.pcb_trace_id = pcb_trace.pcb_trace_id;
-    for (const point of mergedRoute) {
-      if (point.route_type === "via") {
-        db.pcb_via.insert({
-          pcb_trace_id: pcb_trace.pcb_trace_id,
-          x: point.x,
-          y: point.y,
-          hole_diameter: 0.3,
-          outer_diameter: 0.6,
-          layers: [point.from_layer, point.to_layer],
-          from_layer: point.from_layer,
-          to_layer: point.to_layer
-        });
-      }
-    }
-    this._insertErrorIfTraceIsOutsideBoard(mergedRoute, ports);
+    Trace_doInitialPcbTraceRender(this);
   }
   _doInitialSchematicTraceRenderWithDisplayLabel() {
-    if (this.root?.schematicDisabled) return;
-    const { db } = this.root;
-    const { _parsedProps: props, parent } = this;
-    if (!parent) throw new Error("Trace has no parent");
-    const { allPortsFound, portsWithSelectors: connectedPorts } = this._findConnectedPorts();
-    if (!allPortsFound) return;
-    const portsWithPosition = connectedPorts.map(({ port }) => ({
-      port,
-      position: port._getGlobalSchematicPositionAfterLayout(),
-      schematic_port_id: port.schematic_port_id,
-      facingDirection: port.facingDirection
-    }));
-    if (portsWithPosition.length < 2) {
-      throw new Error("Expected at least two ports in portsWithPosition.");
-    }
-    let fromPortName;
-    let toPortName;
-    const fromAnchorPos = portsWithPosition[0].position;
-    const fromPort = portsWithPosition[0].port;
-    if ("path" in this.props) {
-      if (this.props.path.length !== 2) {
-        throw new Error("Invalid 'path': Must contain exactly two elements.");
-      }
-      ;
-      [fromPortName, toPortName] = this.props.path;
-    } else {
-      if (!("from" in this.props && "to" in this.props)) {
-        throw new Error("Missing 'from' or 'to' properties in props.");
-      }
-      fromPortName = this.props.from;
-      toPortName = this.props.to;
-    }
-    if (!fromPort.source_port_id) {
-      throw new Error(
-        `Missing source_port_id for the 'from' port (${fromPortName}).`
-      );
-    }
-    const toAnchorPos = portsWithPosition[1].position;
-    const toPort = portsWithPosition[1].port;
-    if (!toPort.source_port_id) {
-      throw new Error(
-        `Missing source_port_id for the 'to' port (${toPortName}).`
-      );
-    }
-    const existingFromNetLabel = db.schematic_net_label.list().find((label) => label.source_net_id === fromPort.source_port_id);
-    const existingToNetLabel = db.schematic_net_label.list().find((label) => label.source_net_id === toPort.source_port_id);
-    const [firstPort, secondPort] = connectedPorts.map(({ port }) => port);
-    const isFirstPortSchematicBox = firstPort.parent?.config.shouldRenderAsSchematicBox;
-    const pinFullName = isFirstPortSchematicBox ? `${firstPort?.parent?.props.name}_${firstPort?.props.name}` : `${secondPort?.parent?.props.name}_${secondPort?.props.name}`;
-    const netLabelText = this.props.schDisplayLabel ?? pinFullName;
-    if (existingFromNetLabel && existingFromNetLabel.text !== netLabelText) {
-      existingFromNetLabel.text = `${netLabelText} / ${existingFromNetLabel.text}`;
-    }
-    if (existingToNetLabel && existingToNetLabel?.text !== netLabelText) {
-      existingToNetLabel.text = `${netLabelText} / ${existingToNetLabel.text}`;
-    }
-    if (!existingToNetLabel) {
-      const toSide = getEnteringEdgeFromDirection(toPort.facingDirection) ?? "bottom";
-      db.schematic_net_label.insert({
-        text: this.props.schDisplayLabel ?? pinFullName,
-        source_net_id: toPort.source_port_id,
-        anchor_position: toAnchorPos,
-        center: computeSchematicNetLabelCenter({
-          anchor_position: toAnchorPos,
-          anchor_side: toSide,
-          text: this.props.schDisplayLabel ?? pinFullName
-        }),
-        anchor_side: toSide
-      });
-    }
-    if (!existingFromNetLabel) {
-      const fromSide = getEnteringEdgeFromDirection(fromPort.facingDirection) ?? "bottom";
-      db.schematic_net_label.insert({
-        text: this.props.schDisplayLabel ?? pinFullName,
-        source_net_id: fromPort.source_port_id,
-        anchor_position: fromAnchorPos,
-        center: computeSchematicNetLabelCenter({
-          anchor_position: fromAnchorPos,
-          anchor_side: fromSide,
-          text: this.props.schDisplayLabel ?? pinFullName
-        }),
-        anchor_side: fromSide
-      });
-    }
+    Trace__doInitialSchematicTraceRenderWithDisplayLabel(this);
   }
   _isSymbolToChipConnection() {
     const { allPortsFound, ports } = this._findConnectedPorts();
@@ -5383,235 +5634,7 @@ var Trace2 = class extends PrimitiveComponent2 {
     return isPort1Chip && isPort2Chip;
   }
   doInitialSchematicTraceRender() {
-    if (this.root?.schematicDisabled) return;
-    const { db } = this.root;
-    const { _parsedProps: props, parent } = this;
-    if (!parent) throw new Error("Trace has no parent");
-    const { allPortsFound, portsWithSelectors: connectedPorts } = this._findConnectedPorts();
-    const { netsWithSelectors } = this._findConnectedNets();
-    if (!allPortsFound) return;
-    const portIds = connectedPorts.map((p) => p.port.schematic_port_id).sort();
-    const portPairKey = portIds.join(",");
-    const board = this.root?._getBoard();
-    if (board?._connectedSchematicPortPairs) {
-      if (board._connectedSchematicPortPairs.has(portPairKey)) {
-        return;
-      }
-    }
-    const connection = {
-      name: this.source_trace_id,
-      pointsToConnect: []
-    };
-    const obstacles = getSchematicObstaclesForTrace(this);
-    const portsWithPosition = connectedPorts.map(({ port }) => ({
-      port,
-      position: port._getGlobalSchematicPositionAfterLayout(),
-      schematic_port_id: port.schematic_port_id ?? void 0,
-      facingDirection: port.facingDirection
-    }));
-    const isPortAndNetConnection = portsWithPosition.length === 1 && netsWithSelectors.length === 1;
-    if (isPortAndNetConnection) {
-      const net = netsWithSelectors[0].net;
-      const { port, position: anchorPos } = portsWithPosition[0];
-      let connectedNetLabel = this.getSubcircuit().selectAll("netlabel").find((nl) => {
-        const conn = nl._parsedProps.connection ?? nl._parsedProps.connectsTo;
-        if (!conn) return false;
-        if (Array.isArray(conn)) {
-          return conn.some((selector) => {
-            const targetPort2 = this.getSubcircuit().selectOne(selector, {
-              port: true
-            });
-            return targetPort2 === port;
-          });
-        }
-        const targetPort = this.getSubcircuit().selectOne(conn, {
-          port: true
-        });
-        return targetPort === port;
-      });
-      if (!connectedNetLabel) {
-        const dbNetLabel = db.schematic_net_label.getWhere({
-          source_trace_id: this.source_trace_id
-        });
-        if (dbNetLabel) {
-          connectedNetLabel = dbNetLabel;
-        }
-      }
-      if (connectedNetLabel) {
-        const labelPos = "_getGlobalSchematicPositionBeforeLayout" in connectedNetLabel ? connectedNetLabel._getGlobalSchematicPositionBeforeLayout() : connectedNetLabel.anchor_position;
-        const edges2 = [];
-        if (anchorPos.x === labelPos.x || anchorPos.y === labelPos.y) {
-          edges2.push({ from: anchorPos, to: labelPos });
-        } else {
-          edges2.push({ from: anchorPos, to: { x: labelPos.x, y: anchorPos.y } });
-          edges2.push({ from: { x: labelPos.x, y: anchorPos.y }, to: labelPos });
-        }
-        const trace2 = db.schematic_trace.insert({
-          source_trace_id: this.source_trace_id,
-          edges: edges2,
-          junctions: []
-        });
-        this.schematic_trace_id = trace2.schematic_trace_id;
-        return;
-      }
-      if (this.props.schDisplayLabel) {
-        const side2 = getEnteringEdgeFromDirection(port.facingDirection) ?? "bottom";
-        db.schematic_net_label.insert({
-          text: this.props.schDisplayLabel,
-          source_net_id: net.source_net_id,
-          anchor_position: anchorPos,
-          center: computeSchematicNetLabelCenter({
-            anchor_position: anchorPos,
-            anchor_side: side2,
-            text: this.props.schDisplayLabel
-          }),
-          anchor_side: side2
-        });
-        return;
-      }
-      const side = getEnteringEdgeFromDirection(port.facingDirection) ?? "bottom";
-      const netLabel = db.schematic_net_label.insert({
-        text: net._parsedProps.name,
-        source_net_id: net.source_net_id,
-        anchor_position: anchorPos,
-        center: computeSchematicNetLabelCenter({
-          anchor_position: anchorPos,
-          anchor_side: side,
-          text: net._parsedProps.name
-        }),
-        anchor_side: side
-      });
-      return;
-    }
-    if (this.props.schDisplayLabel) {
-      if ("from" in this.props && "to" in this.props || "path" in this.props) {
-        this._doInitialSchematicTraceRenderWithDisplayLabel();
-        return;
-      }
-    }
-    if (portsWithPosition.length < 2) {
-      return;
-    }
-    connection.pointsToConnect = portsWithPosition.map(({ position }) => ({
-      ...position,
-      layer: "top"
-    }));
-    const bounds = computeObstacleBounds(obstacles);
-    const BOUNDS_MARGIN = 2;
-    const simpleRouteJsonInput = {
-      minTraceWidth: 0.1,
-      obstacles,
-      connections: [connection],
-      bounds: {
-        minX: bounds.minX - BOUNDS_MARGIN,
-        maxX: bounds.maxX + BOUNDS_MARGIN,
-        minY: bounds.minY - BOUNDS_MARGIN,
-        maxY: bounds.maxY + BOUNDS_MARGIN
-      },
-      layerCount: 1
-    };
-    let Autorouter = MultilayerIjump;
-    let skipOtherTraceInteraction = false;
-    if (this.getSubcircuit().props._schDirectLineRoutingEnabled) {
-      Autorouter = DirectLineRouter;
-      skipOtherTraceInteraction = true;
-    }
-    const autorouter = new Autorouter({
-      input: simpleRouteJsonInput,
-      MAX_ITERATIONS: 100,
-      OBSTACLE_MARGIN: 0.1,
-      isRemovePathLoopsEnabled: true,
-      isShortenPathWithShortcutsEnabled: true,
-      marginsWithCosts: [
-        {
-          margin: 1,
-          enterCost: 0,
-          travelCostFactor: 1
-        },
-        {
-          margin: 0.3,
-          enterCost: 0,
-          travelCostFactor: 1
-        },
-        {
-          margin: 0.2,
-          enterCost: 0,
-          travelCostFactor: 2
-        },
-        {
-          margin: 0.1,
-          enterCost: 0,
-          travelCostFactor: 3
-        }
-      ]
-    });
-    let results = autorouter.solveAndMapToTraces();
-    if (results.length === 0) {
-      if (this._isSymbolToChipConnection() || this._isSymbolToSymbolConnection() || this._isChipToChipConnection()) {
-        this._doInitialSchematicTraceRenderWithDisplayLabel();
-        return;
-      }
-      const directLineRouter = new DirectLineRouter({
-        input: simpleRouteJsonInput
-      });
-      results = directLineRouter.solveAndMapToTraces();
-      skipOtherTraceInteraction = true;
-    }
-    const [{ route }] = results;
-    let edges = [];
-    for (let i = 0; i < route.length - 1; i++) {
-      edges.push({
-        from: route[i],
-        to: route[i + 1]
-      });
-    }
-    const source_trace_id = this.source_trace_id;
-    let junctions = [];
-    if (!skipOtherTraceInteraction) {
-      pushEdgesOfSchematicTraceToPreventOverlap({ edges, db, source_trace_id });
-      const otherEdges = getOtherSchematicTraces({
-        db,
-        source_trace_id,
-        differentNetOnly: true
-      }).flatMap((t) => t.edges);
-      edges = createSchematicTraceCrossingSegments({ edges, otherEdges });
-      junctions = createSchematicTraceJunctions({
-        edges,
-        db,
-        source_trace_id: this.source_trace_id
-      });
-    }
-    const lastEdge = edges[edges.length - 1];
-    const lastEdgePort = portsWithPosition[portsWithPosition.length - 1];
-    const lastDominantDirection = getDominantDirection(lastEdge);
-    edges.push(
-      ...getStubEdges({ lastEdge, lastEdgePort, lastDominantDirection })
-    );
-    const firstEdge = edges[0];
-    const firstEdgePort = portsWithPosition[0];
-    const firstDominantDirection = getDominantDirection(firstEdge);
-    edges.unshift(
-      ...getStubEdges({
-        firstEdge,
-        firstEdgePort,
-        firstDominantDirection
-      })
-    );
-    if (!this.source_trace_id) {
-      throw new Error("Missing source_trace_id for schematic trace insertion.");
-    }
-    if (this.getSubcircuit()._parsedProps.schTraceAutoLabelEnabled && countComplexElements(junctions, edges) >= 5 && (this._isSymbolToChipConnection() || this._isSymbolToSymbolConnection() || this._isChipToChipConnection())) {
-      this._doInitialSchematicTraceRenderWithDisplayLabel();
-      return;
-    }
-    const trace = db.schematic_trace.insert({
-      source_trace_id: this.source_trace_id,
-      edges,
-      junctions
-    });
-    this.schematic_trace_id = trace.schematic_trace_id;
-    if (board?._connectedSchematicPortPairs)
-      board._connectedSchematicPortPairs.add(portPairKey);
+    Trace_doInitialSchematicTraceRender(this);
   }
 };
 
@@ -6456,7 +6479,7 @@ var NormalComponent = class extends PrimitiveComponent2 {
         const targets = Array.isArray(target) ? target : [target];
         for (const targetPath of targets) {
           this.add(
-            new Trace2({
+            new Trace3({
               from: `${this.getSubcircuitSelector()} > port.${pinName}`,
               to: targetPath
             })
@@ -6638,7 +6661,7 @@ var CapacityMeshAutorouter = class {
 
 // lib/components/primitive-components/Group/Group.ts
 import "circuit-json";
-import Debug5 from "debug";
+import Debug6 from "debug";
 import "zod";
 
 // lib/components/primitive-components/TraceHint.ts
@@ -6887,7 +6910,7 @@ var applyEditEvents = ({
 // lib/utils/autorouting/getSimpleRouteJsonFromCircuitJson.ts
 import { su as su4 } from "@tscircuit/circuit-json-util";
 import {
-  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson2
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson3
 } from "circuit-json-to-connectivity-map";
 
 // lib/utils/autorouting/getAncestorSubcircuitIds.ts
@@ -6938,7 +6961,7 @@ var getSimpleRouteJsonFromCircuitJson = ({
   );
   const board = db.pcb_board.list()[0];
   db = su4(subcircuitElements);
-  const connMap = getFullConnectivityMapFromCircuitJson2(subcircuitElements);
+  const connMap = getFullConnectivityMapFromCircuitJson3(subcircuitElements);
   const obstacles = getObstaclesFromCircuitJson(
     [
       ...db.pcb_component.list(),
@@ -7287,64 +7310,60 @@ import {
 // lib/components/primitive-components/Group/Group_doInitialSchematicLayoutMatchAdapt.ts
 import "@tscircuit/circuit-json-util";
 import "circuit-json-to-connectivity-map";
-import corpus from "@tscircuit/schematic-corpus";
-import { convertCircuitJsonToBpc } from "circuit-json-to-bpc";
+import { corpusNoNetLabel } from "@tscircuit/schematic-corpus";
 import {
-  layoutSchematicGraph
+  convertCircuitJsonToBpc
+} from "circuit-json-to-bpc";
+import {
+  layoutSchematicGraph,
+  getGraphicsForBpcGraph
 } from "bpc-graph";
+import "graphics-debug";
+import "circuit-to-svg";
+import Debug5 from "debug";
+var debug4 = Debug5("Group_doInitialSchematicLayoutMatchAdapt");
 function Group_doInitialSchematicLayoutMatchAdapt(group) {
   const { db } = group.root;
   const subtreeCircuitJson = structuredClone(db.toArray());
-  const existingLabels = new Set(
-    subtreeCircuitJson.filter((e) => e.type === "schematic_net_label").map((e) => `${e.anchor_position?.x},${e.anchor_position?.y}`)
-  );
-  const oppositeSideFromFacing = {
-    left: "right",
-    right: "left",
-    top: "bottom",
-    bottom: "top"
-  };
-  const generatedNetLabels = /* @__PURE__ */ new Map();
-  for (const sp of subtreeCircuitJson.filter(
-    (e) => e.type === "schematic_port"
-  )) {
-    const key = `${sp.center.x},${sp.center.y}`;
-    if (existingLabels.has(key)) continue;
-    const srcPort = db.source_port.get(sp.source_port_id);
-    const srcNet = db.source_net.getWhere({
-      subcircuit_connectivity_map_key: srcPort?.subcircuit_connectivity_map_key
-    });
-    if (!srcNet) {
-      console.error(`No source net found for port: ${sp.source_port_id}`);
-      continue;
-    }
-    const srcTrace = db.source_trace.getWhere({
-      subcircuit_connectivity_map_key: srcPort?.subcircuit_connectivity_map_key
-    });
-    const schematic_net_label_id = `netlabel_for_${sp.schematic_port_id}`;
-    const source_net = db.source_net.get(srcNet.source_net_id);
-    const schematic_net_label = {
-      type: "schematic_net_label",
-      schematic_net_label_id,
-      text: source_net.name,
-      source_net_id: srcNet.source_net_id,
-      source_trace_id: srcTrace?.source_trace_id,
-      anchor_position: { ...sp.center },
-      center: { ...sp.center },
-      anchor_side: oppositeSideFromFacing[sp.facing_direction] ?? "right"
-    };
-    generatedNetLabels.set(schematic_net_label_id, {
-      schematic_net_label,
-      schematic_port: sp
-    });
-    subtreeCircuitJson.push(schematic_net_label);
+  const bpcGraphBeforeGeneratedNetLabels = convertCircuitJsonToBpc(subtreeCircuitJson);
+  console.log("Writing bpcGraphBeforeGeneratedNetLabels.svg");
+  if (debug4.enabled) {
+    global.debugGraphics?.push(
+      getGraphicsForBpcGraph(bpcGraphBeforeGeneratedNetLabels, {
+        title: "floatingBpcGraph"
+      })
+    );
   }
-  const targetBpcGraph = convertCircuitJsonToBpc(subtreeCircuitJson);
+  const targetBpcGraph = convertCircuitJsonToBpc(
+    subtreeCircuitJson
+    // .concat(implicitNetLabels),
+  );
   const laidOutBpcGraph = layoutSchematicGraph(targetBpcGraph, {
     singletonKeys: ["vcc/2", "gnd/2"],
     centerPinColors: ["netlabel_center", "component_center"],
-    corpus
+    floatingBoxIdsWithMutablePinOffsets: new Set(
+      targetBpcGraph.boxes.filter((box) => {
+        const boxPins = targetBpcGraph.pins.filter(
+          (p) => p.boxId === box.boxId
+        );
+        const nonCenterBoxPins = boxPins.filter(
+          (bp) => !bp.color.includes("center")
+        );
+        if (nonCenterBoxPins.length <= 2) {
+          return true;
+        }
+        return false;
+      }).map((b) => b.boxId)
+    ),
+    corpus: corpusNoNetLabel
   });
+  if (debug4.enabled) {
+    global.debugGraphics?.push(
+      getGraphicsForBpcGraph(laidOutBpcGraph, {
+        title: "laidOutBpcGraph"
+      })
+    );
+  }
   const groupOffset = group._getGlobalSchematicPositionBeforeLayout();
   for (const box of laidOutBpcGraph.boxes) {
     if (!box.center) continue;
@@ -7394,36 +7413,6 @@ function Group_doInitialSchematicLayoutMatchAdapt(group) {
       };
       continue;
     }
-    if (generatedNetLabels.has(box.boxId)) {
-      const { schematic_net_label: generatedNetLabel, schematic_port } = generatedNetLabels.get(box.boxId);
-      const pins = laidOutBpcGraph.pins.filter((p) => p.boxId === box.boxId);
-      const center = pins.find((p) => p.color === "netlabel_center");
-      const anchor = pins.find((p) => p.color !== "netlabel_center");
-      const color = anchor.color;
-      const symbolName = color === "vcc" ? "vcc" : color === "gnd" ? "gnd" : void 0;
-      const anchorSide = color === "vcc" ? "bottom" : color === "gnd" ? "top" : oppositeSideFromFacing[schematic_port.facing_direction] ?? "right";
-      const source_net = db.source_net.get(generatedNetLabel.source_net_id);
-      const schematic_net_label2 = {
-        type: "schematic_net_label",
-        schematic_net_label_id: `netlabel_for_${box.boxId}`,
-        text: source_net.name,
-        // no text; just a placeholder box for Match-Adapt
-        anchor_position: {
-          x: box.center.x + groupOffset.x + center.offset.x,
-          y: box.center.y + groupOffset.y + center.offset.y
-        },
-        center: {
-          x: box.center.x + groupOffset.x + center.offset.x,
-          y: box.center.y + groupOffset.y + center.offset.y
-        },
-        anchor_side: anchorSide,
-        symbol_name: symbolName,
-        source_net_id: generatedNetLabel.source_net_id,
-        source_trace_id: generatedNetLabel.source_trace_id
-      };
-      db.schematic_net_label.insert(schematic_net_label2);
-      continue;
-    }
     console.error(
       `No schematic element found for box: ${box.boxId}. This is a bug in the matchAdapt binding with @tscircuit/core`
     );
@@ -7924,20 +7913,20 @@ var Group = class extends NormalComponent {
     return false;
   }
   _hasTracesToRoute() {
-    const debug4 = Debug5("tscircuit:core:_hasTracesToRoute");
+    const debug5 = Debug6("tscircuit:core:_hasTracesToRoute");
     const traces = this.selectAll("trace");
-    debug4(`[${this.getString()}] has ${traces.length} traces to route`);
+    debug5(`[${this.getString()}] has ${traces.length} traces to route`);
     return traces.length > 0;
   }
   async _runEffectMakeHttpAutoroutingRequest() {
     const { db } = this.root;
-    const debug4 = Debug5("tscircuit:core:_runEffectMakeHttpAutoroutingRequest");
+    const debug5 = Debug6("tscircuit:core:_runEffectMakeHttpAutoroutingRequest");
     const props = this._parsedProps;
     const autorouterConfig = this._getAutorouterConfig();
     const serverUrl = autorouterConfig.serverUrl;
     const serverMode = autorouterConfig.serverMode;
     const fetchWithDebug = (url, options) => {
-      debug4("fetching", url);
+      debug5("fetching", url);
       if (options.headers) {
         options.headers["Tscircuit-Core-Version"] = this.root?.getCoreVersion();
       }
@@ -8053,8 +8042,8 @@ var Group = class extends NormalComponent {
   async _runLocalAutorouting() {
     const { db } = this.root;
     const props = this._parsedProps;
-    const debug4 = Debug5("tscircuit:core:_runLocalAutorouting");
-    debug4(`[${this.getString()}] starting local autorouting`);
+    const debug5 = Debug6("tscircuit:core:_runLocalAutorouting");
+    debug5(`[${this.getString()}] starting local autorouting`);
     const autorouterConfig = this._getAutorouterConfig();
     const { simpleRouteJson } = getSimpleRouteJsonFromCircuitJson({
       db,
@@ -8079,11 +8068,11 @@ var Group = class extends NormalComponent {
     const routingPromise = new Promise(
       (resolve, reject) => {
         autorouter.on("complete", (event) => {
-          debug4(`[${this.getString()}] local autorouting complete`);
+          debug5(`[${this.getString()}] local autorouting complete`);
           resolve(event.traces);
         });
         autorouter.on("error", (event) => {
-          debug4(
+          debug5(
             `[${this.getString()}] local autorouting error: ${event.error.message}`
           );
           reject(event.error);
@@ -8140,30 +8129,30 @@ var Group = class extends NormalComponent {
     }
   }
   doInitialPcbTraceRender() {
-    const debug4 = Debug5("tscircuit:core:doInitialPcbTraceRender");
+    const debug5 = Debug6("tscircuit:core:doInitialPcbTraceRender");
     if (!this.isSubcircuit) return;
     if (this.root?.pcbDisabled) return;
     if (this.getInheritedProperty("routingDisabled")) return;
     if (this._shouldUseTraceByTraceRouting()) return;
     if (!this._areChildSubcircuitsRouted()) {
-      debug4(
+      debug5(
         `[${this.getString()}] child subcircuits are not routed, skipping async autorouting until subcircuits routed`
       );
       return;
     }
-    debug4(
+    debug5(
       `[${this.getString()}] no child subcircuits to wait for, initiating async routing`
     );
     if (!this._hasTracesToRoute()) return;
     this._startAsyncAutorouting();
   }
   updatePcbTraceRender() {
-    const debug4 = Debug5("tscircuit:core:updatePcbTraceRender");
-    debug4(`[${this.getString()}] updating...`);
+    const debug5 = Debug6("tscircuit:core:updatePcbTraceRender");
+    debug5(`[${this.getString()}] updating...`);
     if (!this.isSubcircuit) return;
     if (this._shouldRouteAsync() && this._hasTracesToRoute() && !this._hasStartedAsyncAutorouting) {
       if (this._areChildSubcircuitsRouted()) {
-        debug4(
+        debug5(
           `[${this.getString()}] child subcircuits are now routed, starting async autorouting`
         );
         this._startAsyncAutorouting();
@@ -8174,14 +8163,14 @@ var Group = class extends NormalComponent {
     if (this._shouldUseTraceByTraceRouting()) return;
     const { db } = this.root;
     if (this._asyncAutoroutingResult.output_simple_route_json) {
-      debug4(
+      debug5(
         `[${this.getString()}] updating PCB traces from simple route json (${this._asyncAutoroutingResult.output_simple_route_json.traces?.length} traces)`
       );
       this._updatePcbTraceRenderFromSimpleRouteJson();
       return;
     }
     if (this._asyncAutoroutingResult.output_pcb_traces) {
-      debug4(
+      debug5(
         `[${this.getString()}] updating PCB traces from ${this._asyncAutoroutingResult.output_pcb_traces.length} traces`
       );
       this._updatePcbTraceRenderFromPcbTraces();
@@ -8653,13 +8642,13 @@ var Capacitor = class extends NormalComponent {
   doInitialCreateTracesFromProps() {
     if (this.props.decouplingFor && this.props.decouplingTo) {
       this.add(
-        new Trace2({
+        new Trace3({
           from: `${this.getSubcircuitSelector()} > port.1`,
           to: this.props.decouplingFor
         })
       );
       this.add(
-        new Trace2({
+        new Trace3({
           from: `${this.getSubcircuitSelector()} > port.2`,
           to: this.props.decouplingTo
         })
@@ -8735,7 +8724,7 @@ var Chip = class extends NormalComponent {
     if (props.externallyConnectedPins) {
       for (const [pin1, pin2] of props.externallyConnectedPins) {
         this.add(
-          new Trace2({
+          new Trace3({
             from: `${this.getSubcircuitSelector()} > port.${pin1}`,
             to: `${this.getSubcircuitSelector()} > port.${pin2}`
           })
@@ -9192,13 +9181,13 @@ var Resistor = class extends NormalComponent {
   doInitialCreateTracesFromProps() {
     if (this.props.pullupFor && this.props.pullupTo) {
       this.add(
-        new Trace2({
+        new Trace3({
           from: `${this.getSubcircuitSelector()} > port.1`,
           to: this.props.pullupFor
         })
       );
       this.add(
-        new Trace2({
+        new Trace3({
           from: `${this.getSubcircuitSelector()} > port.2`,
           to: this.props.pullupTo
         })
@@ -9206,13 +9195,13 @@ var Resistor = class extends NormalComponent {
     }
     if (this.props.pulldownFor && this.props.pulldownTo) {
       this.add(
-        new Trace2({
+        new Trace3({
           from: `${this.getSubcircuitSelector()} > port.1`,
           to: this.props.pulldownFor
         })
       );
       this.add(
-        new Trace2({
+        new Trace3({
           from: `${this.getSubcircuitSelector()} > port.2`,
           to: this.props.pulldownTo
         })
@@ -9611,7 +9600,7 @@ var NetLabel = class extends PrimitiveComponent2 {
     if (!connectsTo) return;
     for (const connection of connectsTo) {
       this.add(
-        new Trace2({
+        new Trace3({
           from: connection,
           to: `net.${this._getNetName()}`
         })
@@ -10725,7 +10714,7 @@ import { identity as identity5 } from "transformation-matrix";
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.549",
+  version: "0.0.551",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -10759,7 +10748,7 @@ var package_default = {
     "@tscircuit/math-utils": "^0.0.18",
     "@tscircuit/props": "^0.0.251",
     "@tscircuit/schematic-autolayout": "^0.0.6",
-    "@tscircuit/schematic-corpus": "^0.0.50",
+    "@tscircuit/schematic-corpus": "^0.0.52",
     "@tscircuit/schematic-match-adapt": "^0.0.16",
     "@tscircuit/simple-3d-svg": "^0.0.6",
     "@types/bun": "^1.2.16",
@@ -10767,18 +10756,18 @@ var package_default = {
     "@types/react": "^19.0.1",
     "@types/react-dom": "^19.0.2",
     "@types/react-reconciler": "^0.28.9",
-    "bpc-graph": "^0.0.50",
+    "bpc-graph": "^0.0.53",
     "bun-match-svg": "0.0.12",
     "calculate-elbow": "^0.0.5",
     "chokidar-cli": "^3.0.0",
     "circuit-json": "^0.0.215",
-    "circuit-json-to-bpc": "^0.0.7",
+    "circuit-json-to-bpc": "^0.0.13",
     "circuit-json-to-connectivity-map": "^0.0.22",
     "circuit-json-to-simple-3d": "^0.0.2",
     "circuit-to-svg": "^0.0.162",
     concurrently: "^9.1.2",
     debug: "^4.3.6",
-    "graphics-debug": "^0.0.57",
+    "graphics-debug": "^0.0.60",
     howfat: "^0.3.8",
     "live-server": "^1.2.2",
     "looks-same": "^9.0.1",
@@ -11258,7 +11247,7 @@ export {
   Subcircuit,
   Switch,
   TestPoint,
-  Trace2 as Trace,
+  Trace3 as Trace,
   TraceHint,
   Transistor,
   Via,