@tscircuit/core 0.0.645 → 0.0.647

package/dist/index.js

@@ -1,10 +1,8 @@
 var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // lib/components/index.ts
 var components_exports = {};
@@ -23,7 +21,7 @@ __export(components_exports, {
   FabricationNoteText: () => FabricationNoteText,
   Footprint: () => Footprint,
   Fuse: () => Fuse,
-  Group: () => Group,
+  Group: () => Group6,
   Hole: () => Hole,
   Inductor: () => Inductor,
   Jumper: () => Jumper,
@@ -125,18 +123,18 @@ var orderedRenderPhases = [
 ];
 var globalRenderCounter = 0;
 var Renderable = class {
+  renderPhaseStates;
+  shouldBeRemoved = false;
+  children;
+  /** PCB-only SMTPads, PlatedHoles, Holes, Silkscreen elements etc. */
+  isPcbPrimitive = false;
+  /** Schematic-only, lines, boxes, indicators etc. */
+  isSchematicPrimitive = false;
+  _renderId;
+  _currentRenderPhase = null;
+  _asyncEffects = [];
+  parent = null;
   constructor(props) {
-    __publicField(this, "renderPhaseStates");
-    __publicField(this, "shouldBeRemoved", false);
-    __publicField(this, "children");
-    /** PCB-only SMTPads, PlatedHoles, Holes, Silkscreen elements etc. */
-    __publicField(this, "isPcbPrimitive", false);
-    /** Schematic-only, lines, boxes, indicators etc. */
-    __publicField(this, "isSchematicPrimitive", false);
-    __publicField(this, "_renderId");
-    __publicField(this, "_currentRenderPhase", null);
-    __publicField(this, "_asyncEffects", []);
-    __publicField(this, "parent", null);
     this._renderId = `${globalRenderCounter++}`;
     this.children = [];
     this.renderPhaseStates = {};
@@ -540,58 +538,17 @@ var cssSelectOptionsInsideSubcircuit = {
   cacheResults: true
 };
 var PrimitiveComponent2 = class extends Renderable {
-  constructor(props) {
-    super(props);
-    __publicField(this, "parent", null);
-    __publicField(this, "children");
-    __publicField(this, "childrenPendingRemoval");
-    __publicField(this, "props");
-    __publicField(this, "_parsedProps");
-    __publicField(this, "externallyAddedAliases");
-    /**
-     * A primitive container is a component that contains one or more ports and
-     * primitive components that are designed to interact.
-     *
-     * For example a resistor contains ports and smtpads that interact, so the
-     * resistor is a primitive container. Inside a primitive container, the ports
-     * and pads are likely to reference each other and look for eachother during
-     * the port matching phase.
-     *
-     */
-    __publicField(this, "isPrimitiveContainer", false);
-    __publicField(this, "canHaveTextChildren", false);
-    __publicField(this, "source_group_id", null);
-    __publicField(this, "source_component_id", null);
-    __publicField(this, "schematic_component_id", null);
-    __publicField(this, "pcb_component_id", null);
-    __publicField(this, "cad_component_id", null);
-    __publicField(this, "fallbackUnassignedName");
-    __publicField(this, "_cachedSelectAllQueries", /* @__PURE__ */ new Map());
-    __publicField(this, "_cachedSelectOneQueries", /* @__PURE__ */ new Map());
-    this.children = [];
-    this.childrenPendingRemoval = [];
-    this.props = props ?? {};
-    this.externallyAddedAliases = [];
-    const zodProps = "partial" in this.config.zodProps ? this.config.zodProps.partial({
-      name: true
-    }) : this.config.zodProps;
-    const parsePropsResult = zodProps.safeParse(props ?? {});
-    if (parsePropsResult.success) {
-      this._parsedProps = parsePropsResult.data;
-    } else {
-      throw new InvalidProps(
-        this.lowercaseComponentName,
-        this.props,
-        parsePropsResult.error.format()
-      );
-    }
-  }
+  parent = null;
+  children;
+  childrenPendingRemoval;
   get config() {
     return {
       componentName: "",
       zodProps: z.object({}).passthrough()
     };
   }
+  props;
+  _parsedProps;
   get componentName() {
     return this.config.componentName;
   }
@@ -611,6 +568,7 @@ var PrimitiveComponent2 = class extends Renderable {
   get lowercaseComponentName() {
     return this.componentName.toLowerCase();
   }
+  externallyAddedAliases;
   /**
    * An subcircuit is self-contained. All the selectors inside
    * a subcircuit are relative to the subcircuit group. You can have multiple
@@ -626,6 +584,44 @@ var PrimitiveComponent2 = class extends Renderable {
   get name() {
     return this._parsedProps.name ?? this.fallbackUnassignedName;
   }
+  /**
+   * A primitive container is a component that contains one or more ports and
+   * primitive components that are designed to interact.
+   *
+   * For example a resistor contains ports and smtpads that interact, so the
+   * resistor is a primitive container. Inside a primitive container, the ports
+   * and pads are likely to reference each other and look for eachother during
+   * the port matching phase.
+   *
+   */
+  isPrimitiveContainer = false;
+  canHaveTextChildren = false;
+  source_group_id = null;
+  source_component_id = null;
+  schematic_component_id = null;
+  pcb_component_id = null;
+  cad_component_id = null;
+  fallbackUnassignedName;
+  constructor(props) {
+    super(props);
+    this.children = [];
+    this.childrenPendingRemoval = [];
+    this.props = props ?? {};
+    this.externallyAddedAliases = [];
+    const zodProps = "partial" in this.config.zodProps ? this.config.zodProps.partial({
+      name: true
+    }) : this.config.zodProps;
+    const parsePropsResult = zodProps.safeParse(props ?? {});
+    if (parsePropsResult.success) {
+      this._parsedProps = parsePropsResult.data;
+    } else {
+      throw new InvalidProps(
+        this.lowercaseComponentName,
+        this.props,
+        parsePropsResult.error.format()
+      );
+    }
+  }
   setProps(props) {
     const newProps = this.config.zodProps.parse({
       ...this.props,
@@ -1033,6 +1029,7 @@ var PrimitiveComponent2 = class extends Renderable {
       }
     }
   }
+  _cachedSelectAllQueries = /* @__PURE__ */ new Map();
   selectAll(selectorRaw) {
     if (this._cachedSelectAllQueries.has(selectorRaw)) {
       return this._cachedSelectAllQueries.get(
@@ -1054,6 +1051,7 @@ var PrimitiveComponent2 = class extends Renderable {
     this._cachedSelectAllQueries.set(selectorRaw, result2);
     return result2;
   }
+  _cachedSelectOneQueries = /* @__PURE__ */ new Map();
   selectOne(selectorRaw, options) {
     if (this._cachedSelectOneQueries.has(selectorRaw)) {
       return this._cachedSelectOneQueries.get(selectorRaw);
@@ -1073,11 +1071,11 @@ var PrimitiveComponent2 = class extends Renderable {
         (n) => n.lowercaseComponentName === options.type
       );
     }
-    result ?? (result = selectOne(
+    result ??= selectOne(
       selector,
       this,
       cssSelectOptionsInsideSubcircuit
-    ));
+    );
     if (result) {
       this._cachedSelectOneQueries.set(selectorRaw, result);
       return result;
@@ -1503,10 +1501,7 @@ var netProps = z4.object({
   )
 });
 var Net = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "source_net_id");
-  }
+  source_net_id;
   get config() {
     return {
       componentName: "Net",
@@ -1711,12 +1706,9 @@ var createNetsFromProps = (component, props) => {
 import { smtPadProps } from "@tscircuit/props";
 import { decomposeTSR } from "transformation-matrix";
 var SmtPad = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "pcb_smtpad_id", null);
-    __publicField(this, "matchedPort", null);
-    __publicField(this, "isPcbPrimitive", true);
-  }
+  pcb_smtpad_id = null;
+  matchedPort = null;
+  isPcbPrimitive = true;
   get config() {
     return {
       componentName: "SmtPad",
@@ -1974,11 +1966,8 @@ var SmtPad = class extends PrimitiveComponent2 {
 import { silkscreenPathProps } from "@tscircuit/props";
 import { applyToPoint as applyToPoint2 } from "transformation-matrix";
 var SilkscreenPath = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "pcb_silkscreen_path_id", null);
-    __publicField(this, "isPcbPrimitive", true);
-  }
+  pcb_silkscreen_path_id = null;
+  isPcbPrimitive = true;
   get config() {
     return {
       componentName: "SilkscreenPath",
@@ -2073,11 +2062,8 @@ var pcbTraceProps = z5.object({
   source_trace_id: z5.string().optional()
 });
 var PcbTrace = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "pcb_trace_id", null);
-    __publicField(this, "isPcbPrimitive", true);
-  }
+  pcb_trace_id = null;
+  isPcbPrimitive = true;
   get config() {
     return {
       componentName: "PcbTrace",
@@ -2144,12 +2130,9 @@ var PcbTrace = class extends PrimitiveComponent2 {
 // lib/components/primitive-components/PlatedHole.ts
 import { platedHoleProps } from "@tscircuit/props";
 var PlatedHole = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "pcb_plated_hole_id", null);
-    __publicField(this, "matchedPort", null);
-    __publicField(this, "isPcbPrimitive", true);
-  }
+  pcb_plated_hole_id = null;
+  matchedPort = null;
+  isPcbPrimitive = true;
   get config() {
     return {
       componentName: "PlatedHole",
@@ -2372,11 +2355,8 @@ var PlatedHole = class extends PrimitiveComponent2 {
 import { pcbKeepoutProps } from "@tscircuit/props";
 import { decomposeTSR as decomposeTSR2 } from "transformation-matrix";
 var Keepout = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "pcb_keepout_id", null);
-    __publicField(this, "isPcbPrimitive", true);
-  }
+  pcb_keepout_id = null;
+  isPcbPrimitive = true;
   get config() {
     return {
       componentName: "Keepout",
@@ -2430,11 +2410,8 @@ var Keepout = class extends PrimitiveComponent2 {
 // lib/components/primitive-components/Hole.ts
 import { holeProps } from "@tscircuit/props";
 var Hole = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "pcb_hole_id", null);
-    __publicField(this, "isPcbPrimitive", true);
-  }
+  pcb_hole_id = null;
+  isPcbPrimitive = true;
   get config() {
     return {
       componentName: "Hole",
@@ -2490,10 +2467,7 @@ var Hole = class extends PrimitiveComponent2 {
 // lib/components/primitive-components/SilkscreenText.ts
 import { silkscreenTextProps } from "@tscircuit/props";
 var SilkscreenText = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "isPcbPrimitive", true);
-  }
+  isPcbPrimitive = true;
   get config() {
     return {
       componentName: "SilkscreenText",
@@ -2543,11 +2517,8 @@ var SilkscreenText = class extends PrimitiveComponent2 {
 import { applyToPoint as applyToPoint4 } from "transformation-matrix";
 import { cutoutProps } from "@tscircuit/props";
 var Cutout = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "pcb_cutout_id", null);
-    __publicField(this, "isPcbPrimitive", true);
-  }
+  pcb_cutout_id = null;
+  isPcbPrimitive = true;
   get config() {
     return {
       componentName: "Cutout",
@@ -3010,6 +2981,19 @@ var portProps = z6.object({
   aliases: z6.array(z6.string()).optional()
 });
 var Port = class extends PrimitiveComponent2 {
+  source_port_id = null;
+  pcb_port_id = null;
+  schematic_port_id = null;
+  schematicSymbolPortDef = null;
+  matchedComponents;
+  facingDirection = null;
+  originDescription = null;
+  get config() {
+    return {
+      componentName: "Port",
+      zodProps: portProps
+    };
+  }
   constructor(props, opts = {}) {
     if (!props.name && props.pinNumber !== void 0)
       props.name = `pin${props.pinNumber}`;
@@ -3017,24 +3001,11 @@ var Port = class extends PrimitiveComponent2 {
       throw new Error("Port must have a name or a pinNumber");
     }
     super(props);
-    __publicField(this, "source_port_id", null);
-    __publicField(this, "pcb_port_id", null);
-    __publicField(this, "schematic_port_id", null);
-    __publicField(this, "schematicSymbolPortDef", null);
-    __publicField(this, "matchedComponents");
-    __publicField(this, "facingDirection", null);
-    __publicField(this, "originDescription", null);
     if (opts.originDescription) {
       this.originDescription = opts.originDescription;
     }
     this.matchedComponents = [];
   }
-  get config() {
-    return {
-      componentName: "Port",
-      zodProps: portProps
-    };
-  }
   _getGlobalPcbPositionBeforeLayout() {
     const matchedPcbElm = this.matchedComponents.find((c) => c.isPcbPrimitive);
     const parentComponent = this.parent;
@@ -3904,8 +3875,8 @@ import "circuit-json-to-connectivity-map";
 
 // lib/utils/autorouting/DirectLineRouter.ts
 var DirectLineRouter = class {
+  input;
   constructor({ input }) {
-    __publicField(this, "input");
     this.input = input;
   }
   solveAndMapToTraces() {
@@ -4197,7 +4168,7 @@ var getMaxLengthFromConnectedCapacitors = (ports, { db }) => {
       return sourceComponent.max_decoupling_trace_length;
     }
     return null;
-  }).filter((length6) => length6 !== null);
+  }).filter((length7) => length7 !== null);
   if (capacitorMaxLengths.length === 0) return void 0;
   return Math.min(...capacitorMaxLengths);
 };
@@ -5071,7 +5042,7 @@ var convertFacingDirectionToElbowDirection = (facingDirection) => {
 };
 
 // lib/errors/AutorouterError.ts
-import packageJson from "@tscircuit/capacity-autorouter/package.json";
+import packageJson from "@tscircuit/capacity-autorouter/package.json" with { type: "json" };
 var autorouterVersion = packageJson.version ?? "unknown";
 var AutorouterError = class extends Error {
   constructor(message) {
@@ -5091,6 +5062,7 @@ var TraceConnectionError = class extends Error {
 
 // lib/components/primitive-components/Trace/Trace_doInitialSchematicTraceRender.ts
 var Trace_doInitialSchematicTraceRender = (trace) => {
+  if (trace.root?._featureMspSchematicTraceRouting) return;
   if (trace._couldNotFindPort) return;
   if (trace.root?.schematicDisabled) return;
   const { db } = trace.root;
@@ -5972,15 +5944,15 @@ function Trace__findConnectedPorts(trace) {
 
 // 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;
+  _couldNotFindPort;
   constructor(props) {
     super(props);
-    __publicField(this, "source_trace_id", null);
-    __publicField(this, "pcb_trace_id", null);
-    __publicField(this, "schematic_trace_id", null);
-    __publicField(this, "_portsRoutedOnPcb");
-    __publicField(this, "subcircuit_connectivity_map_key", null);
-    __publicField(this, "_traceConnectionHash", null);
-    __publicField(this, "_couldNotFindPort");
     this._portsRoutedOnPcb = [];
   }
   get config() {
@@ -6200,17 +6172,12 @@ var rotation3 = z8.object({
   z: rotation
 });
 var NormalComponent = class extends PrimitiveComponent2 {
-  constructor(props) {
-    super(props);
-    __publicField(this, "reactSubtrees", []);
-    __publicField(this, "_impliedFootprint");
-    __publicField(this, "isPrimitiveContainer", true);
-    __publicField(this, "_asyncSupplierPartNumbers");
-    __publicField(this, "pcb_missing_footprint_error_id");
-    __publicField(this, "_hasStartedFootprintUrlLoad", false);
-    this._addChildrenFromStringFootprint();
-    this.initPorts();
-  }
+  reactSubtrees = [];
+  _impliedFootprint;
+  isPrimitiveContainer = true;
+  _asyncSupplierPartNumbers;
+  pcb_missing_footprint_error_id;
+  _hasStartedFootprintUrlLoad = false;
   /**
    * Override this property for component defaults
    */
@@ -6225,6 +6192,11 @@ var NormalComponent = class extends PrimitiveComponent2 {
       )
     );
   }
+  constructor(props) {
+    super(props);
+    this._addChildrenFromStringFootprint();
+    this.initPorts();
+  }
   /**
    * Override this method for better control over the auto-discovery of ports.
    *
@@ -6415,7 +6387,7 @@ var NormalComponent = class extends PrimitiveComponent2 {
   _addChildrenFromStringFootprint() {
     const { pcbRotation, pinLabels, pcbPinLabels } = this.props;
     let { footprint } = this.props;
-    footprint ?? (footprint = this._getImpliedFootprintString?.());
+    footprint ??= this._getImpliedFootprintString?.();
     if (!footprint) return;
     if (typeof footprint === "string") {
       if (this._isFootprintUrl(footprint)) return;
@@ -6671,7 +6643,7 @@ var NormalComponent = class extends PrimitiveComponent2 {
   }
   doInitialPcbFootprintStringRender() {
     let { footprint } = this.props;
-    footprint ?? (footprint = this._getImpliedFootprintString?.());
+    footprint ??= this._getImpliedFootprintString?.();
     if (!footprint) return;
     const { pcbRotation, pinLabels, pcbPinLabels } = this.props;
     if (typeof footprint === "string" && this._isFootprintUrl(footprint)) {
@@ -7072,18 +7044,18 @@ import {
 // lib/utils/autorouting/CapacityMeshAutorouter.ts
 import { CapacityMeshSolver } from "@tscircuit/capacity-autorouter";
 var CapacityMeshAutorouter = class {
+  input;
+  isRouting = false;
+  solver;
+  eventHandlers = {
+    complete: [],
+    error: [],
+    progress: []
+  };
+  cycleCount = 0;
+  stepDelay;
+  timeoutId;
   constructor(input, options = {}) {
-    __publicField(this, "input");
-    __publicField(this, "isRouting", false);
-    __publicField(this, "solver");
-    __publicField(this, "eventHandlers", {
-      complete: [],
-      error: [],
-      progress: []
-    });
-    __publicField(this, "cycleCount", 0);
-    __publicField(this, "stepDelay");
-    __publicField(this, "timeoutId");
     this.input = input;
     const { capacityDepth, targetMinCapacity, stepDelay = 0 } = options;
     this.solver = new CapacityMeshSolver(input, {
@@ -7219,17 +7191,14 @@ var CapacityMeshAutorouter = class {
 
 // lib/components/primitive-components/Group/Group.ts
 import "circuit-json";
-import Debug8 from "debug";
+import Debug9 from "debug";
 import "zod";
 
 // lib/components/primitive-components/TraceHint.ts
 import { traceHintProps } from "@tscircuit/props";
 import { applyToPoint as applyToPoint6 } from "transformation-matrix";
 var TraceHint = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "matchedPort", null);
-  }
+  matchedPort = null;
   get config() {
     return {
       componentName: "TraceHint",
@@ -7743,7 +7712,7 @@ var getSimpleRouteJsonFromCircuitJson = ({
     if (!conn) continue;
     if (![...tracePortIds].every((pid) => pointIdToConn.get(pid) === conn))
       continue;
-    conn.externallyConnectedPointIds ?? (conn.externallyConnectedPointIds = []);
+    conn.externallyConnectedPointIds ??= [];
     conn.externallyConnectedPointIds.push([...tracePortIds]);
   }
   return {
@@ -8024,7 +7993,7 @@ function convertTreeToInputProblem(tree, db, group) {
     netMap: {},
     pinStrongConnMap: {},
     netConnMap: {},
-    chipGap: 0.4,
+    chipGap: 0.6,
     partitionGap: 1.2
   };
   debug5(
@@ -9501,16 +9470,770 @@ var Group_doInitialPcbLayoutFlex = (group) => {
 
 // lib/components/primitive-components/Group/Group.ts
 import { convertSrjToGraphicsObject } from "@tscircuit/capacity-autorouter";
-var Group = class extends NormalComponent {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "pcb_group_id", null);
-    __publicField(this, "schematic_group_id", null);
-    __publicField(this, "subcircuit_id", null);
-    __publicField(this, "_hasStartedAsyncAutorouting", false);
-    __publicField(this, "_asyncAutoroutingResult", null);
-    __publicField(this, "unnamedElementCounter", {});
+
+// lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/Group_doInitialSchematicTraceRender.ts
+import { SchematicTracePipelineSolver as SchematicTracePipelineSolver4 } from "@tscircuit/schematic-trace-solver";
+import Debug8 from "debug";
+
+// lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/createSchematicTraceSolverInputProblem.ts
+import "@tscircuit/schematic-trace-solver";
+function createSchematicTraceSolverInputProblem(group) {
+  const { db } = group.root;
+  const sckToSourceNet = /* @__PURE__ */ new Map();
+  const sckToUserNetId = /* @__PURE__ */ new Map();
+  const allScks = /* @__PURE__ */ new Set();
+  const traces = group.selectAll("trace");
+  const displayLabelTraces = traces.filter(
+    (t) => t._parsedProps?.schDisplayLabel
+  );
+  const displayLabelSourceTraceIds = new Set(
+    displayLabelTraces.map((t) => t.source_trace_id).filter((id) => Boolean(id))
+  );
+  const childGroups = group.selectAll("group");
+  const allSchematicGroupIds = [
+    group.schematic_group_id,
+    ...childGroups.map((a) => a.schematic_group_id)
+  ];
+  const schematicComponents = db.schematic_component.list().filter((a) => allSchematicGroupIds.includes(a.schematic_group_id));
+  const chips = [];
+  const pinIdToSchematicPortId = /* @__PURE__ */ new Map();
+  const schematicPortIdToPinId = /* @__PURE__ */ new Map();
+  for (const schematicComponent of schematicComponents) {
+    const chipId = schematicComponent.schematic_component_id;
+    const pins = [];
+    const sourceComponent = db.source_component.getWhere({
+      source_component_id: schematicComponent.source_component_id
+    });
+    const schematicPorts = db.schematic_port.list({
+      schematic_component_id: schematicComponent.schematic_component_id
+    });
+    for (const schematicPort of schematicPorts) {
+      const pinId = `${sourceComponent?.name ?? schematicComponent.schematic_component_id}.${schematicPort.pin_number}`;
+      pinIdToSchematicPortId.set(pinId, schematicPort.schematic_port_id);
+      schematicPortIdToPinId.set(schematicPort.schematic_port_id, pinId);
+    }
+    for (const schematicPort of schematicPorts) {
+      const pinId = schematicPortIdToPinId.get(schematicPort.schematic_port_id);
+      pins.push({
+        pinId,
+        x: schematicPort.center.x,
+        y: schematicPort.center.y
+      });
+    }
+    chips.push({
+      chipId,
+      center: schematicComponent.center,
+      width: schematicComponent.size.width,
+      height: schematicComponent.size.height,
+      pins
+    });
+  }
+  const allSourceAndSchematicPortIdsInScope = /* @__PURE__ */ new Set();
+  const schPortIdToSourcePortId = /* @__PURE__ */ new Map();
+  const sourcePortIdToSchPortId = /* @__PURE__ */ new Map();
+  const userNetIdToSck = /* @__PURE__ */ new Map();
+  for (const sc of schematicComponents) {
+    const ports = db.schematic_port.list({
+      schematic_component_id: sc.schematic_component_id
+    });
+    for (const sp of ports) {
+      allSourceAndSchematicPortIdsInScope.add(sp.schematic_port_id);
+      if (sp.source_port_id) {
+        schPortIdToSourcePortId.set(sp.schematic_port_id, sp.source_port_id);
+        sourcePortIdToSchPortId.set(sp.source_port_id, sp.schematic_port_id);
+      }
+    }
+  }
+  const allowedSubcircuitIds = /* @__PURE__ */ new Set();
+  if (group.subcircuit_id) allowedSubcircuitIds.add(group.subcircuit_id);
+  for (const cg of childGroups) {
+    if (cg.subcircuit_id) allowedSubcircuitIds.add(cg.subcircuit_id);
+  }
+  const directConnections = [];
+  const pairKeyToSourceTraceId = /* @__PURE__ */ new Map();
+  for (const st of db.source_trace.list()) {
+    if (displayLabelSourceTraceIds.has(st.source_trace_id)) continue;
+    if (st.subcircuit_id && !allowedSubcircuitIds.has(st.subcircuit_id)) {
+      continue;
+    }
+    const connected = (st.connected_source_port_ids ?? []).map((srcId) => sourcePortIdToSchPortId.get(srcId)).filter(
+      (sourcePortId) => Boolean(sourcePortId) && allSourceAndSchematicPortIdsInScope.has(sourcePortId)
+    );
+    if (connected.length >= 2) {
+      const [a, b] = connected.slice(0, 2);
+      const pairKey = [a, b].sort().join("::");
+      if (!pairKeyToSourceTraceId.has(pairKey)) {
+        pairKeyToSourceTraceId.set(pairKey, st.source_trace_id);
+        const userNetId = st.display_name ?? st.source_trace_id;
+        if (st.subcircuit_connectivity_map_key) {
+          allScks.add(st.subcircuit_connectivity_map_key);
+          userNetIdToSck.set(userNetId, st.subcircuit_connectivity_map_key);
+          sckToUserNetId.set(st.subcircuit_connectivity_map_key, userNetId);
+        }
+        directConnections.push({
+          pinIds: [a, b].map((id) => schematicPortIdToPinId.get(id)),
+          netId: userNetId
+        });
+      }
+    }
+  }
+  const netConnections = [];
+  for (const net of db.source_net.list().filter((n) => allowedSubcircuitIds.has(n.subcircuit_id))) {
+    if (net.subcircuit_connectivity_map_key) {
+      allScks.add(net.subcircuit_connectivity_map_key);
+      sckToSourceNet.set(net.subcircuit_connectivity_map_key, net);
+    }
+  }
+  const sckToPinIds = /* @__PURE__ */ new Map();
+  for (const [schId, srcPortId] of schPortIdToSourcePortId) {
+    const sp = db.source_port.get(srcPortId);
+    if (!sp?.subcircuit_connectivity_map_key) continue;
+    const sck = sp.subcircuit_connectivity_map_key;
+    allScks.add(sck);
+    if (!sckToPinIds.has(sck)) sckToPinIds.set(sck, []);
+    sckToPinIds.get(sck).push(schId);
+  }
+  for (const [subcircuitConnectivityKey, schematicPortIds] of sckToPinIds) {
+    const sourceNet = sckToSourceNet.get(subcircuitConnectivityKey);
+    if (sourceNet && schematicPortIds.length >= 2) {
+      const userNetId = String(
+        sourceNet.name || sourceNet.source_net_id || subcircuitConnectivityKey
+      );
+      userNetIdToSck.set(userNetId, subcircuitConnectivityKey);
+      sckToUserNetId.set(subcircuitConnectivityKey, userNetId);
+      netConnections.push({
+        netId: userNetId,
+        pinIds: schematicPortIds.map(
+          (portId) => schematicPortIdToPinId.get(portId)
+        )
+      });
+    }
+  }
+  const availableNetLabelOrientations = (() => {
+    const netToAllowedOrientations = {};
+    const presentNetIds = new Set(netConnections.map((nc) => nc.netId));
+    for (const net of db.source_net.list().filter(
+      (n) => !n.subcircuit_id || allowedSubcircuitIds.has(n.subcircuit_id)
+    )) {
+      if (!net.name) continue;
+      if (!presentNetIds.has(net.name)) continue;
+      if (net.name === "GND") {
+        netToAllowedOrientations[net.name] = ["y-"];
+      } else if (/^V/.test(net.name)) {
+        netToAllowedOrientations[net.name] = ["y+"];
+      }
+    }
+    return netToAllowedOrientations;
+  })();
+  const inputProblem = {
+    chips,
+    directConnections,
+    netConnections,
+    availableNetLabelOrientations,
+    maxMspPairDistance: 2
+  };
+  return {
+    inputProblem,
+    pinIdToSchematicPortId,
+    pairKeyToSourceTraceId,
+    sckToSourceNet,
+    sckToUserNetId,
+    userNetIdToSck,
+    allSourceAndSchematicPortIdsInScope,
+    schPortIdToSourcePortId,
+    displayLabelTraces,
+    allScks
+  };
+}
+
+// lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/applyTracesFromSolverOutput.ts
+import "@tscircuit/schematic-trace-solver";
+
+// lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/compute-crossings.ts
+var TOL = 1e-6;
+function isHorizontalEdge(edge) {
+  const dx = Math.abs(edge.to.x - edge.from.x);
+  const dy = Math.abs(edge.to.y - edge.from.y);
+  return dx >= dy;
+}
+function length6(a, b) {
+  return Math.hypot(b.x - a.x, b.y - a.y);
+}
+function pointAt(a, b, t) {
+  return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+}
+function paramAlong(a, b, p) {
+  const L = length6(a, b);
+  if (L < TOL) return 0;
+  const t = ((p.x - a.x) * (b.x - a.x) + (p.y - a.y) * (b.y - a.y)) / ((b.x - a.x) * (b.x - a.x) + (b.y - a.y) * (b.y - a.y));
+  return Math.max(0, Math.min(1, t)) * L;
+}
+function cross(ax, ay, bx, by) {
+  return ax * by - ay * bx;
+}
+function segmentIntersection(p1, p2, q1, q2) {
+  const r = { x: p2.x - p1.x, y: p2.y - p1.y };
+  const s = { x: q2.x - q1.x, y: q2.y - q1.y };
+  const rxs = cross(r.x, r.y, s.x, s.y);
+  const q_p = { x: q1.x - p1.x, y: q1.y - p1.y };
+  const q_pxr = cross(q_p.x, q_p.y, r.x, r.y);
+  if (Math.abs(rxs) < TOL && Math.abs(q_pxr) < TOL) {
+    return null;
+  }
+  if (Math.abs(rxs) < TOL && Math.abs(q_pxr) >= TOL) {
+    return null;
+  }
+  const t = cross(q_p.x, q_p.y, s.x, s.y) / rxs;
+  const u = cross(q_p.x, q_p.y, r.x, r.y) / rxs;
+  if (t < -TOL || t > 1 + TOL || u < -TOL || u > 1 + TOL) return null;
+  const pt = { x: p1.x + t * r.x, y: p1.y + t * r.y };
+  return pt;
+}
+function mergeIntervals(intervals, tol = TOL) {
+  if (intervals.length === 0) return intervals;
+  intervals.sort((a, b) => a.start - b.start);
+  const merged = [];
+  let cur = { ...intervals[0] };
+  for (let i = 1; i < intervals.length; i++) {
+    const nxt = intervals[i];
+    if (nxt.start <= cur.end + tol) {
+      cur.end = Math.max(cur.end, nxt.end);
+    } else {
+      merged.push(cur);
+      cur = { ...nxt };
+    }
+  }
+  merged.push(cur);
+  return merged;
+}
+function splitEdgeByCrossings(edge, crossingDistances, crossLen) {
+  const L = length6(edge.from, edge.to);
+  if (L < TOL || crossingDistances.length === 0) return [edge];
+  const half = crossLen / 2;
+  const rawIntervals = crossingDistances.map((d) => ({
+    start: Math.max(0, d - half),
+    end: Math.min(L, d + half)
+  })).filter((iv) => iv.end - iv.start > TOL);
+  const intervals = mergeIntervals(rawIntervals);
+  const result = [];
+  let cursor = 0;
+  const dir = { x: edge.to.x - edge.from.x, y: edge.to.y - edge.from.y };
+  const addSeg = (d0, d1, isCrossing) => {
+    if (d1 - d0 <= TOL) return;
+    const t0 = d0 / L;
+    const t1 = d1 / L;
+    result.push({
+      from: pointAt(edge.from, edge.to, t0),
+      to: pointAt(edge.from, edge.to, t1),
+      ...isCrossing ? { is_crossing: true } : {}
+    });
+  };
+  for (const iv of intervals) {
+    if (iv.start - cursor > TOL) {
+      addSeg(cursor, iv.start, false);
+    }
+    addSeg(iv.start, iv.end, true);
+    cursor = iv.end;
+  }
+  if (L - cursor > TOL) {
+    addSeg(cursor, L, false);
+  }
+  return result.length > 0 ? result : [edge];
+}
+function computeCrossings(traces, opts = {}) {
+  const crossLen = opts.crossSegmentLength ?? 0.075;
+  const tol = opts.tolerance ?? TOL;
+  const crossingsByEdge = /* @__PURE__ */ new Map();
+  const keyOf = (ref) => `${ref.traceIdx}:${ref.edgeIdx}`;
+  const getEdge = (ref) => traces[ref.traceIdx].edges[ref.edgeIdx];
+  for (let ti = 0; ti < traces.length; ti++) {
+    const A = traces[ti];
+    for (let ei = 0; ei < A.edges.length; ei++) {
+      const eA = A.edges[ei];
+      for (let tj = ti; tj < traces.length; tj++) {
+        const B = traces[tj];
+        for (let ej = tj === ti ? ei + 1 : 0; ej < B.edges.length; ej++) {
+          const eB = B.edges[ej];
+          const P = segmentIntersection(eA.from, eA.to, eB.from, eB.to);
+          if (!P) continue;
+          const LA = length6(eA.from, eA.to);
+          const LB = length6(eB.from, eB.to);
+          if (LA < tol || LB < tol) continue;
+          const dA = paramAlong(eA.from, eA.to, P);
+          const dB = paramAlong(eB.from, eB.to, P);
+          const nearEndpointA = dA <= tol || Math.abs(LA - dA) <= tol || Number.isNaN(dA);
+          const nearEndpointB = dB <= tol || Math.abs(LB - dB) <= tol || Number.isNaN(dB);
+          if (!nearEndpointA && !nearEndpointB) {
+            const aIsHorizontal = isHorizontalEdge(eA);
+            const bIsHorizontal = isHorizontalEdge(eB);
+            let assignToA;
+            if (aIsHorizontal !== bIsHorizontal) {
+              assignToA = aIsHorizontal;
+            } else {
+              const ax = Math.abs(eA.to.x - eA.from.x);
+              const ay = Math.abs(eA.to.y - eA.from.y);
+              const bx = Math.abs(eB.to.x - eB.from.x);
+              const by = Math.abs(eB.to.y - eB.from.y);
+              const aScore = ax - ay;
+              const bScore = bx - by;
+              assignToA = aScore === bScore ? true : aScore > bScore;
+            }
+            const chosenKey = keyOf({
+              traceIdx: assignToA ? ti : tj,
+              edgeIdx: assignToA ? ei : ej
+            });
+            const chosenList = crossingsByEdge.get(chosenKey) ?? [];
+            chosenList.push(assignToA ? dA : dB);
+            crossingsByEdge.set(chosenKey, chosenList);
+          }
+        }
+      }
+    }
+  }
+  const out = traces.map((t) => ({ id: t.id, edges: [] }));
+  for (let ti = 0; ti < traces.length; ti++) {
+    const trace = traces[ti];
+    for (let ei = 0; ei < trace.edges.length; ei++) {
+      const eRefKey = keyOf({ traceIdx: ti, edgeIdx: ei });
+      const splittingDistances = crossingsByEdge.get(eRefKey) ?? [];
+      if (splittingDistances.length === 0) {
+        out[ti].edges.push(trace.edges[ei]);
+        continue;
+      }
+      const uniqueSorted = Array.from(
+        new Set(splittingDistances.map((d) => Number(d.toFixed(6))))
+      ).sort((a, b) => a - b);
+      const split = splitEdgeByCrossings(
+        trace.edges[ei],
+        uniqueSorted,
+        crossLen
+      );
+      out[ti].edges.push(...split);
+    }
+  }
+  return out;
+}
+
+// lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/compute-junctions.ts
+var TOL2 = 1e-6;
+function nearlyEqual(a, b, tol = TOL2) {
+  return Math.abs(a - b) <= tol;
+}
+function pointEq(a, b, tol = TOL2) {
+  return nearlyEqual(a.x, b.x, tol) && nearlyEqual(a.y, b.y, tol);
+}
+function onSegment(p, a, b, tol = TOL2) {
+  const minX = Math.min(a.x, b.x) - tol;
+  const maxX = Math.max(a.x, b.x) + tol;
+  const minY = Math.min(a.y, b.y) - tol;
+  const maxY = Math.max(a.y, b.y) + tol;
+  if (p.x < minX || p.x > maxX || p.y < minY || p.y > maxY) return false;
+  const area = Math.abs((b.x - a.x) * (p.y - a.y) - (b.y - a.y) * (p.x - a.x));
+  return area <= tol;
+}
+function dedupePoints(points, tol = TOL2) {
+  const map = /* @__PURE__ */ new Map();
+  for (const p of points) {
+    const key = `${p.x.toFixed(6)},${p.y.toFixed(6)}`;
+    if (!map.has(key)) map.set(key, p);
+  }
+  return Array.from(map.values());
+}
+function edgeVec(e) {
+  return { x: e.to.x - e.from.x, y: e.to.y - e.from.y };
+}
+function isParallel(e1, e2, tol = TOL2) {
+  const v1 = edgeVec(e1);
+  const v2 = edgeVec(e2);
+  const L1 = Math.hypot(v1.x, v1.y);
+  const L2 = Math.hypot(v2.x, v2.y);
+  if (L1 < tol || L2 < tol) return true;
+  const cross2 = v1.x * v2.y - v1.y * v2.x;
+  return Math.abs(cross2) <= tol * L1 * L2;
+}
+function incidentEdgesAtPoint(trace, p, tol = TOL2) {
+  return trace.edges.filter(
+    (e) => pointEq(e.from, p, tol) || pointEq(e.to, p, tol)
+  );
+}
+function nearestEndpointOnTrace(trace, p, tol = TOL2) {
+  for (const e of trace.edges) {
+    if (pointEq(e.from, p, tol)) return e.from;
+    if (pointEq(e.to, p, tol)) return e.to;
+  }
+  return null;
+}
+function edgeDirectionFromPoint(e, p, tol = TOL2) {
+  const other = pointEq(e.from, p, tol) || nearlyEqual(e.from.x, p.x, tol) && nearlyEqual(e.from.y, p.y, tol) ? e.to : e.from;
+  const dx = other.x - p.x;
+  const dy = other.y - p.y;
+  if (Math.abs(dx) < tol && Math.abs(dy) < tol) return null;
+  if (Math.abs(dx) >= Math.abs(dy)) {
+    return dx >= 0 ? "right" : "left";
+  }
+  return dy >= 0 ? "up" : "down";
+}
+function getCornerOrientationAtPoint(trace, p, tol = TOL2) {
+  const incident = incidentEdgesAtPoint(trace, p, tol);
+  if (incident.length < 2) return null;
+  const dirs = incident.map((e) => edgeDirectionFromPoint(e, p, tol));
+  const hasUp = dirs.includes("up");
+  const hasDown = dirs.includes("down");
+  const hasLeft = dirs.includes("left");
+  const hasRight = dirs.includes("right");
+  const vertical = hasUp ? "up" : hasDown ? "down" : null;
+  const horizontal = hasRight ? "right" : hasLeft ? "left" : null;
+  if (vertical && horizontal) {
+    return `${vertical}-${horizontal}`;
+  }
+  return null;
+}
+function computeJunctions(traces, opts = {}) {
+  const tol = opts.tolerance ?? TOL2;
+  const result = {};
+  for (const t of traces) result[t.id] = [];
+  const endpointsByTrace = traces.map((t) => {
+    const pts = [];
+    for (const e of t.edges) {
+      pts.push(e.from, e.to);
+    }
+    return dedupePoints(pts, tol);
+  });
+  for (let i = 0; i < traces.length; i++) {
+    const A = traces[i];
+    const AEnds = endpointsByTrace[i];
+    for (let j = i + 1; j < traces.length; j++) {
+      const B = traces[j];
+      const BEnds = endpointsByTrace[j];
+      for (const pa of AEnds) {
+        for (const pb of BEnds) {
+          if (pointEq(pa, pb, tol)) {
+            const aEdgesAtP = incidentEdgesAtPoint(A, pa, tol);
+            const bEdgesAtP = incidentEdgesAtPoint(B, pb, tol);
+            const hasCorner = aEdgesAtP.some(
+              (eA) => bEdgesAtP.some((eB) => !isParallel(eA, eB, tol))
+            );
+            const aCorner = getCornerOrientationAtPoint(A, pa, tol);
+            const bCorner = getCornerOrientationAtPoint(B, pb, tol);
+            const sameCornerOrientation = aCorner !== null && bCorner !== null && aCorner === bCorner;
+            if (hasCorner && !sameCornerOrientation) {
+              result[A.id].push(pa);
+              if (A.id !== B.id) result[B.id].push(pb);
+            }
+          }
+        }
+      }
+      for (const pa of AEnds) {
+        for (const eB of B.edges) {
+          if (onSegment(pa, eB.from, eB.to, tol)) {
+            const aEdgesAtP = incidentEdgesAtPoint(A, pa, tol);
+            const hasCorner = aEdgesAtP.some((eA) => !isParallel(eA, eB, tol));
+            const aCorner = getCornerOrientationAtPoint(A, pa, tol);
+            const bEndpointNearPa = nearestEndpointOnTrace(B, pa, tol * 1e3);
+            const bCorner = bEndpointNearPa ? getCornerOrientationAtPoint(B, bEndpointNearPa, tol) : null;
+            const sameCornerOrientation = aCorner !== null && bCorner !== null && aCorner === bCorner;
+            if (hasCorner && !sameCornerOrientation) {
+              result[A.id].push(pa);
+              if (A.id !== B.id) result[B.id].push(pa);
+            }
+          }
+        }
+      }
+      for (const pb of BEnds) {
+        for (const eA of A.edges) {
+          if (onSegment(pb, eA.from, eA.to, tol)) {
+            const bEdgesAtP = incidentEdgesAtPoint(B, pb, tol);
+            const hasCorner = bEdgesAtP.some((eB) => !isParallel(eA, eB, tol));
+            const bCorner = getCornerOrientationAtPoint(B, pb, tol);
+            const aEndpointNearPb = nearestEndpointOnTrace(A, pb, tol * 1e3);
+            const aCorner = aEndpointNearPb ? getCornerOrientationAtPoint(A, aEndpointNearPb, tol) : null;
+            const sameCornerOrientation = aCorner !== null && bCorner !== null && aCorner === bCorner;
+            if (hasCorner && !sameCornerOrientation) {
+              result[B.id].push(pb);
+              if (A.id !== B.id) result[A.id].push(pb);
+            }
+          }
+        }
+      }
+    }
   }
+  for (const id of Object.keys(result)) {
+    result[id] = dedupePoints(result[id], tol);
+  }
+  return result;
+}
+
+// lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/applyTracesFromSolverOutput.ts
+function applyTracesFromSolverOutput(args) {
+  const { group, solver, pinIdToSchematicPortId, pairKeyToSourceTraceId } = args;
+  const { db } = group.root;
+  const correctedMap = solver.traceOverlapShiftSolver?.correctedTraceMap;
+  const pendingTraces = [];
+  for (const solved of Object.values(correctedMap ?? {})) {
+    const points = solved?.tracePath;
+    if (!Array.isArray(points) || points.length < 2) continue;
+    const edges = [];
+    for (let i = 0; i < points.length - 1; i++) {
+      edges.push({
+        from: { x: points[i].x, y: points[i].y },
+        to: { x: points[i + 1].x, y: points[i + 1].y }
+      });
+    }
+    let source_trace_id = null;
+    if (Array.isArray(solved?.pins) && solved.pins.length === 2) {
+      const pA = pinIdToSchematicPortId.get(solved.pins[0]?.pinId);
+      const pB = pinIdToSchematicPortId.get(solved.pins[1]?.pinId);
+      if (pA && pB) {
+        const pairKey = [pA, pB].sort().join("::");
+        source_trace_id = pairKeyToSourceTraceId.get(pairKey) || `solver_${solved.mspPairId || pairKey}`;
+        for (const schPid of [pA, pB]) {
+          const existing = db.schematic_port.get(schPid);
+          if (existing) db.schematic_port.update(schPid, { is_connected: true });
+        }
+      }
+    }
+    if (!source_trace_id) {
+      source_trace_id = `solver_${solved?.mspPairId}`;
+    }
+    pendingTraces.push({
+      id: source_trace_id,
+      edges
+    });
+  }
+  const withCrossings = computeCrossings(
+    pendingTraces.map((t) => ({ id: t.id, edges: t.edges }))
+  );
+  const junctionsById = computeJunctions(withCrossings);
+  for (const t of withCrossings) {
+    db.schematic_trace.insert({
+      source_trace_id: t.id,
+      edges: t.edges,
+      junctions: junctionsById[t.id] ?? []
+    });
+  }
+}
+
+// lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/applyNetLabelPlacements.ts
+import "@tscircuit/schematic-trace-solver";
+
+// lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/oppositeSide.ts
+var oppositeSide = (input) => {
+  switch (input) {
+    case "x+":
+      return "left";
+    case "x-":
+      return "right";
+    case "y+":
+      return "bottom";
+    case "y-":
+      return "top";
+    case "left":
+      return "right";
+    case "top":
+      return "bottom";
+    case "right":
+      return "left";
+    case "bottom":
+      return "top";
+  }
+};
+
+// lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/applyNetLabelPlacements.ts
+function applyNetLabelPlacements(args) {
+  const {
+    group,
+    solver,
+    sckToSourceNet,
+    allScks,
+    allSourceAndSchematicPortIdsInScope,
+    schPortIdToSourcePortId,
+    userNetIdToSck
+  } = args;
+  const { db } = group.root;
+  const netLabelPlacements = solver.netLabelPlacementSolver?.netLabelPlacements ?? [];
+  const globalConnMap = solver.mspConnectionPairSolver.globalConnMap;
+  for (const placement of netLabelPlacements) {
+    const placementUserNetId = globalConnMap.getIdsConnectedToNet(placement.globalConnNetId).find((id) => userNetIdToSck.get(id));
+    const placementSck = userNetIdToSck.get(placementUserNetId);
+    const anchor_position = placement.anchorPoint;
+    const orientation = placement.orientation;
+    const anchor_side = oppositeSide(orientation);
+    const sourceNet = placementSck ? sckToSourceNet.get(placementSck) : void 0;
+    if (!sourceNet) {
+      continue;
+    }
+    const text = sourceNet.name;
+    const hasExistingLabelForNet = db.schematic_net_label.list().some((nl) => {
+      if (sourceNet?.source_net_id && nl.source_net_id) {
+        return nl.source_net_id === sourceNet.source_net_id;
+      }
+      return nl.text === text;
+    });
+    if (hasExistingLabelForNet) continue;
+    const center = placement.center ?? computeSchematicNetLabelCenter({
+      anchor_position,
+      anchor_side,
+      text
+    });
+    db.schematic_net_label.insert({
+      text,
+      anchor_position,
+      center,
+      anchor_side,
+      ...sourceNet?.source_net_id ? { source_net_id: sourceNet.source_net_id } : {}
+    });
+  }
+}
+
+// lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/insertNetLabelsForTracesExcludedFromRouting.ts
+import "@tscircuit/schematic-trace-solver";
+function insertNetLabelsForTracesExcludedFromRouting(args) {
+  const { group, displayLabelTraces } = args;
+  const { db } = group.root;
+  for (const trace of displayLabelTraces) {
+    const label = trace._parsedProps?.schDisplayLabel;
+    if (!label) continue;
+    try {
+      const res = trace._findConnectedPorts?.();
+      if (!res?.allPortsFound || !res.ports || res.ports.length < 1) continue;
+      const ports = res.ports.slice(0, 2);
+      for (const port of ports) {
+        const anchor_position = port._getGlobalSchematicPositionAfterLayout();
+        const side = getEnteringEdgeFromDirection(port.facingDirection || "right") || "right";
+        const center = computeSchematicNetLabelCenter({
+          anchor_position,
+          anchor_side: side,
+          text: label
+        });
+        db.schematic_net_label.insert({
+          text: label,
+          anchor_position,
+          center,
+          anchor_side: side,
+          ...trace.source_trace_id ? { source_trace_id: trace.source_trace_id } : {}
+        });
+      }
+    } catch {
+    }
+  }
+}
+
+// lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/insertNetLabelsForPortsMissingTrace.ts
+var insertNetLabelsForPortsMissingTrace = ({
+  allSourceAndSchematicPortIdsInScope,
+  group,
+  schPortIdToSourcePortId,
+  sckToSourceNet: connKeyToNet
+}) => {
+  const { db } = group.root;
+  for (const schOrSrcPortId of Array.from(
+    allSourceAndSchematicPortIdsInScope
+  )) {
+    const sp = db.schematic_port.get(schOrSrcPortId);
+    if (!sp) continue;
+    if (sp.is_connected) continue;
+    const srcPortId = schPortIdToSourcePortId.get(schOrSrcPortId);
+    if (!srcPortId) continue;
+    const sourcePort = db.source_port.get(srcPortId);
+    const key = sourcePort?.subcircuit_connectivity_map_key;
+    if (!key) continue;
+    const sourceNet = connKeyToNet.get(key);
+    if (!sourceNet) {
+      continue;
+    }
+    const hasLabelForNet = db.schematic_net_label.list().some((nl) => {
+      if (sourceNet.source_net_id && nl.source_net_id) {
+        return nl.source_net_id === sourceNet.source_net_id;
+      }
+      return nl.text === (sourceNet.name || key);
+    });
+    if (hasLabelForNet) continue;
+    const existingAtPort = db.schematic_net_label.list().some((nl) => {
+      const samePos = Math.abs(nl.anchor_position.x - sp.center.x) < 1e-6 && Math.abs(nl.anchor_position.y - sp.center.y) < 1e-6;
+      if (!samePos) return false;
+      if (sourceNet.source_net_id && nl.source_net_id) {
+        return nl.source_net_id === sourceNet.source_net_id;
+      }
+      return nl.text === (sourceNet.name || key);
+    });
+    if (existingAtPort) continue;
+    const text = sourceNet.name || sourceNet.source_net_id || key;
+    const side = getEnteringEdgeFromDirection(sp.facing_direction || "right") || "right";
+    const center = computeSchematicNetLabelCenter({
+      anchor_position: sp.center,
+      anchor_side: side,
+      text
+    });
+    db.schematic_net_label.insert({
+      text,
+      anchor_position: sp.center,
+      center,
+      anchor_side: side,
+      ...sourceNet.source_net_id ? { source_net_id: sourceNet.source_net_id } : {}
+    });
+  }
+};
+
+// lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/Group_doInitialSchematicTraceRender.ts
+var debug7 = Debug8("Group_doInitialSchematicTraceRender");
+var Group_doInitialSchematicTraceRender = (group) => {
+  if (!group.root?._featureMspSchematicTraceRouting) return;
+  if (!group.isSubcircuit) return;
+  if (group.root?.schematicDisabled) return;
+  const {
+    inputProblem,
+    pinIdToSchematicPortId,
+    pairKeyToSourceTraceId,
+    sckToSourceNet,
+    allSourceAndSchematicPortIdsInScope,
+    schPortIdToSourcePortId,
+    displayLabelTraces,
+    allScks,
+    userNetIdToSck
+  } = createSchematicTraceSolverInputProblem(group);
+  if (debug7.enabled) {
+    globalThis.debugOutputs?.add(
+      "group-trace-render-input-problem",
+      JSON.stringify(inputProblem, null, 2)
+    );
+  }
+  const solver = new SchematicTracePipelineSolver4(inputProblem);
+  solver.solve();
+  applyTracesFromSolverOutput({
+    group,
+    solver,
+    pinIdToSchematicPortId,
+    pairKeyToSourceTraceId
+  });
+  applyNetLabelPlacements({
+    group,
+    solver,
+    sckToSourceNet,
+    allSourceAndSchematicPortIdsInScope,
+    schPortIdToSourcePortId,
+    allScks,
+    userNetIdToSck
+  });
+  insertNetLabelsForPortsMissingTrace({
+    group,
+    allSourceAndSchematicPortIdsInScope,
+    schPortIdToSourcePortId,
+    sckToSourceNet
+  });
+  insertNetLabelsForTracesExcludedFromRouting({
+    group,
+    solver,
+    displayLabelTraces
+  });
+};
+
+// lib/components/primitive-components/Group/Group.ts
+var Group6 = class extends NormalComponent {
+  pcb_group_id = null;
+  schematic_group_id = null;
+  subcircuit_id = null;
+  _hasStartedAsyncAutorouting = false;
+  _asyncAutoroutingResult = null;
   get config() {
     return {
       zodProps: groupProps,
@@ -9607,9 +10330,9 @@ var Group = class extends NormalComponent {
       });
     }
   }
+  unnamedElementCounter = {};
   getNextAvailableName(elm) {
-    var _a, _b;
-    (_a = this.unnamedElementCounter)[_b = elm.lowercaseComponentName] ?? (_a[_b] = 1);
+    this.unnamedElementCounter[elm.lowercaseComponentName] ??= 1;
     return `unnamed_${elm.lowercaseComponentName}${this.unnamedElementCounter[elm.lowercaseComponentName]++}`;
   }
   _resolvePcbPadding() {
@@ -9669,20 +10392,20 @@ var Group = class extends NormalComponent {
     return false;
   }
   _hasTracesToRoute() {
-    const debug7 = Debug8("tscircuit:core:_hasTracesToRoute");
+    const debug8 = Debug9("tscircuit:core:_hasTracesToRoute");
     const traces = this.selectAll("trace");
-    debug7(`[${this.getString()}] has ${traces.length} traces to route`);
+    debug8(`[${this.getString()}] has ${traces.length} traces to route`);
     return traces.length > 0;
   }
   async _runEffectMakeHttpAutoroutingRequest() {
     const { db } = this.root;
-    const debug7 = Debug8("tscircuit:core:_runEffectMakeHttpAutoroutingRequest");
+    const debug8 = Debug9("tscircuit:core:_runEffectMakeHttpAutoroutingRequest");
     const props = this._parsedProps;
     const autorouterConfig = this._getAutorouterConfig();
     const serverUrl = autorouterConfig.serverUrl;
     const serverMode = autorouterConfig.serverMode;
     const fetchWithDebug = (url, options) => {
-      debug7("fetching", url);
+      debug8("fetching", url);
       if (options.headers) {
         options.headers["Tscircuit-Core-Version"] = this.root?.getCoreVersion();
       }
@@ -9798,15 +10521,15 @@ var Group = class extends NormalComponent {
   async _runLocalAutorouting() {
     const { db } = this.root;
     const props = this._parsedProps;
-    const debug7 = Debug8("tscircuit:core:_runLocalAutorouting");
-    debug7(`[${this.getString()}] starting local autorouting`);
+    const debug8 = Debug9("tscircuit:core:_runLocalAutorouting");
+    debug8(`[${this.getString()}] starting local autorouting`);
     const autorouterConfig = this._getAutorouterConfig();
     const { simpleRouteJson } = getSimpleRouteJsonFromCircuitJson({
       db,
       minTraceWidth: this.props.autorouter?.minTraceWidth ?? 0.15,
       subcircuit_id: this.subcircuit_id
     });
-    if (debug7.enabled) {
+    if (debug8.enabled) {
       const graphicsObject = convertSrjToGraphicsObject(
         simpleRouteJson
       );
@@ -9831,11 +10554,11 @@ var Group = class extends NormalComponent {
     const routingPromise = new Promise(
       (resolve, reject) => {
         autorouter.on("complete", (event) => {
-          debug7(`[${this.getString()}] local autorouting complete`);
+          debug8(`[${this.getString()}] local autorouting complete`);
           resolve(event.traces);
         });
         autorouter.on("error", (event) => {
-          debug7(
+          debug8(
             `[${this.getString()}] local autorouting error: ${event.error.message}`
           );
           reject(event.error);
@@ -9892,30 +10615,33 @@ var Group = class extends NormalComponent {
     }
   }
   doInitialPcbTraceRender() {
-    const debug7 = Debug8("tscircuit:core:doInitialPcbTraceRender");
+    const debug8 = Debug9("tscircuit:core:doInitialPcbTraceRender");
     if (!this.isSubcircuit) return;
     if (this.root?.pcbDisabled) return;
     if (this.getInheritedProperty("routingDisabled")) return;
     if (this._shouldUseTraceByTraceRouting()) return;
     if (!this._areChildSubcircuitsRouted()) {
-      debug7(
+      debug8(
         `[${this.getString()}] child subcircuits are not routed, skipping async autorouting until subcircuits routed`
       );
       return;
     }
-    debug7(
+    debug8(
       `[${this.getString()}] no child subcircuits to wait for, initiating async routing`
     );
     if (!this._hasTracesToRoute()) return;
     this._startAsyncAutorouting();
   }
+  doInitialSchematicTraceRender() {
+    Group_doInitialSchematicTraceRender(this);
+  }
   updatePcbTraceRender() {
-    const debug7 = Debug8("tscircuit:core:updatePcbTraceRender");
-    debug7(`[${this.getString()}] updating...`);
+    const debug8 = Debug9("tscircuit:core:updatePcbTraceRender");
+    debug8(`[${this.getString()}] updating...`);
     if (!this.isSubcircuit) return;
     if (this._shouldRouteAsync() && this._hasTracesToRoute() && !this._hasStartedAsyncAutorouting) {
       if (this._areChildSubcircuitsRouted()) {
-        debug7(
+        debug8(
           `[${this.getString()}] child subcircuits are now routed, starting async autorouting`
         );
         this._startAsyncAutorouting();
@@ -9926,14 +10652,14 @@ var Group = class extends NormalComponent {
     if (this._shouldUseTraceByTraceRouting()) return;
     const { db } = this.root;
     if (this._asyncAutoroutingResult.output_simple_route_json) {
-      debug7(
+      debug8(
         `[${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) {
-      debug7(
+      debug8(
         `[${this.getString()}] updating PCB traces from ${this._asyncAutoroutingResult.output_pcb_traces.length} traces`
       );
       this._updatePcbTraceRenderFromPcbTraces();
@@ -10237,13 +10963,10 @@ import {
   checkEachPcbPortConnectedToPcbTraces,
   checkEachPcbTraceNonOverlapping
 } from "@tscircuit/checks";
-var Board = class extends Group {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "pcb_board_id", null);
-    __publicField(this, "_drcChecksComplete", false);
-    __publicField(this, "_connectedSchematicPortPairs", /* @__PURE__ */ new Set());
-  }
+var Board = class extends Group6 {
+  pcb_board_id = null;
+  _drcChecksComplete = false;
+  _connectedSchematicPortPairs = /* @__PURE__ */ new Set();
   get isSubcircuit() {
     return true;
   }
@@ -10525,10 +11248,7 @@ var Capacitor = class extends NormalComponent {
 // lib/components/normal-components/Chip.ts
 import { chipProps } from "@tscircuit/props";
 var Chip = class extends NormalComponent {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "schematicBoxDimensions", null);
-  }
+  schematicBoxDimensions = null;
   get config() {
     return {
       componentName: "Chip",
@@ -10671,13 +11391,6 @@ var Chip = class extends NormalComponent {
 // lib/components/normal-components/Diode.ts
 import { diodeProps } from "@tscircuit/props";
 var Diode = class extends NormalComponent {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "pos", this.portMap.pin1);
-    __publicField(this, "anode", this.portMap.pin1);
-    __publicField(this, "neg", this.portMap.pin2);
-    __publicField(this, "cathode", this.portMap.pin2);
-  }
   // @ts-ignore
   get config() {
     const symbolMap = {
@@ -10715,6 +11428,10 @@ var Diode = class extends NormalComponent {
     });
     this.source_component_id = source_component.source_component_id;
   }
+  pos = this.portMap.pin1;
+  anode = this.portMap.pin1;
+  neg = this.portMap.pin2;
+  cathode = this.portMap.pin2;
 };
 
 // lib/components/normal-components/Fuse.ts
@@ -10756,10 +11473,7 @@ var Fuse = class extends NormalComponent {
 // lib/components/normal-components/Jumper.ts
 import { jumperProps } from "@tscircuit/props";
 var Jumper = class extends NormalComponent {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "schematicDimensions", null);
-  }
+  schematicDimensions = null;
   get config() {
     return {
       schematicSymbolName: void 0,
@@ -10858,10 +11572,7 @@ var Jumper = class extends NormalComponent {
 // lib/components/normal-components/SolderJumper.ts
 import { solderjumperProps } from "@tscircuit/props";
 var SolderJumper = class extends NormalComponent {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "schematicDimensions", null);
-  }
+  schematicDimensions = null;
   _getPinNumberFromBridgedPinName(pinName) {
     const port = this.selectOne(`port.${pinName}`, {
       type: "port"
@@ -11015,13 +11726,6 @@ var SolderJumper = class extends NormalComponent {
 // lib/components/normal-components/Led.ts
 import { ledProps } from "@tscircuit/props";
 var Led = class extends NormalComponent {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "pos", this.portMap.pin1);
-    __publicField(this, "anode", this.portMap.pin1);
-    __publicField(this, "neg", this.portMap.pin2);
-    __publicField(this, "cathode", this.portMap.pin2);
-  }
   get config() {
     const symbolMap = {
       laser: "laser_diode"
@@ -11061,18 +11765,15 @@ var Led = class extends NormalComponent {
     });
     this.source_component_id = source_component.source_component_id;
   }
+  pos = this.portMap.pin1;
+  anode = this.portMap.pin1;
+  neg = this.portMap.pin2;
+  cathode = this.portMap.pin2;
 };
 
 // lib/components/normal-components/PowerSource.ts
 import { powerSourceProps } from "@tscircuit/props";
 var PowerSource = class extends NormalComponent {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "pos", this.portMap.pin1);
-    __publicField(this, "positive", this.portMap.pin1);
-    __publicField(this, "neg", this.portMap.pin2);
-    __publicField(this, "negative", this.portMap.pin2);
-  }
   // @ts-ignore
   get config() {
     return {
@@ -11103,6 +11804,10 @@ var PowerSource = class extends NormalComponent {
     });
     this.source_component_id = source_component.source_component_id;
   }
+  pos = this.portMap.pin1;
+  positive = this.portMap.pin1;
+  neg = this.portMap.pin2;
+  negative = this.portMap.pin2;
 };
 
 // lib/components/normal-components/VoltageSource.ts
@@ -11119,11 +11824,6 @@ var voltageSourceProps = commonComponentProps.extend({
   phase: rotation2.optional()
 });
 var VoltageSource = class extends NormalComponent {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "terminal1", this.portMap.terminal1);
-    __publicField(this, "terminal2", this.portMap.terminal2);
-  }
   get config() {
     return {
       componentName: "VoltageSource",
@@ -11184,6 +11884,8 @@ var VoltageSource = class extends NormalComponent {
       phase: props.phase
     });
   }
+  terminal1 = this.portMap.terminal1;
+  terminal2 = this.portMap.terminal2;
 };
 
 // lib/components/normal-components/Resistor.ts
@@ -11333,10 +12035,7 @@ var Constraint2 = class extends PrimitiveComponent2 {
 import { fabricationNotePathProps } from "@tscircuit/props";
 import { applyToPoint as applyToPoint7 } from "transformation-matrix";
 var FabricationNotePath = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "fabrication_note_path_id", null);
-  }
+  fabrication_note_path_id = null;
   get config() {
     return {
       componentName: "FabricationNotePath",
@@ -11413,7 +12112,7 @@ var FabricationNoteText = class extends PrimitiveComponent2 {
 
 // lib/components/primitive-components/Group/Subcircuit.ts
 import "@tscircuit/props";
-var Subcircuit = class extends Group {
+var Subcircuit = class extends Group6 {
   constructor(props) {
     super({
       ...props,
@@ -11424,7 +12123,7 @@ var Subcircuit = class extends Group {
 
 // lib/components/primitive-components/Breakout/Breakout.ts
 import "@tscircuit/props";
-var Breakout = class extends Group {
+var Breakout = class extends Group6 {
   constructor(props) {
     super({
       ...props,
@@ -11457,13 +12156,10 @@ var Breakout = class extends Group {
 // lib/components/primitive-components/BreakoutPoint.ts
 import { breakoutPointProps } from "@tscircuit/props";
 var BreakoutPoint = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "pcb_breakout_point_id", null);
-    __publicField(this, "matchedPort", null);
-    __publicField(this, "matchedNet", null);
-    __publicField(this, "isPcbPrimitive", true);
-  }
+  pcb_breakout_point_id = null;
+  matchedPort = null;
+  matchedNet = null;
+  isPcbPrimitive = true;
   get config() {
     return {
       componentName: "BreakoutPoint",
@@ -11542,11 +12238,9 @@ import {
   identity as identity4,
   translate as translate6
 } from "transformation-matrix";
+import { calculateElbow as calculateElbow2 } from "calculate-elbow";
 var NetLabel = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "source_net_label_id");
-  }
+  source_net_label_id;
   get config() {
     return {
       componentName: "NetLabel",
@@ -11657,16 +12351,87 @@ var NetLabel = class extends PrimitiveComponent2 {
       );
     }
   }
+  doInitialSchematicTraceRender() {
+    if (!this.root?._featureMspSchematicTraceRouting) return;
+    if (this.root?.schematicDisabled) return;
+    const { db } = this.root;
+    const connectsTo = this._resolveConnectsTo();
+    if (!connectsTo || connectsTo.length === 0) return;
+    const anchorPos = this._getGlobalSchematicPositionBeforeLayout();
+    const anchorSide = this._getAnchorSide();
+    const sideToAxisDir = {
+      left: "x-",
+      right: "x+",
+      top: "y+",
+      bottom: "y-"
+    };
+    const anchorFacing = sideToAxisDir[anchorSide];
+    const net = this.getSubcircuit().selectOne(
+      `net.${this._getNetName()}`
+    );
+    for (const connection of connectsTo) {
+      const port = this.getSubcircuit().selectOne(connection, {
+        type: "port"
+      });
+      if (!port || !port.schematic_port_id) continue;
+      let existingTraceForThisConnection = false;
+      if (net?.source_net_id) {
+        const candidateSourceTrace = db.source_trace.list().find(
+          (st) => st.connected_source_net_ids?.includes(net.source_net_id) && st.connected_source_port_ids?.includes(port.source_port_id ?? "")
+        );
+        if (candidateSourceTrace) {
+          existingTraceForThisConnection = db.schematic_trace.list().some(
+            (t) => t.source_trace_id === candidateSourceTrace.source_trace_id
+          );
+        }
+        if (existingTraceForThisConnection) continue;
+      }
+      const portPos = port._getGlobalSchematicPositionAfterLayout();
+      const portFacing = convertFacingDirectionToElbowDirection(
+        port.facingDirection ?? "right"
+      ) ?? "x+";
+      const path = calculateElbow2(
+        {
+          x: portPos.x,
+          y: portPos.y,
+          facingDirection: portFacing
+        },
+        {
+          x: anchorPos.x,
+          y: anchorPos.y,
+          facingDirection: anchorFacing
+        }
+      );
+      if (!Array.isArray(path) || path.length < 2) continue;
+      const edges = [];
+      for (let i = 0; i < path.length - 1; i++) {
+        edges.push({
+          from: { x: path[i].x, y: path[i].y },
+          to: { x: path[i + 1].x, y: path[i + 1].y }
+        });
+      }
+      let source_trace_id;
+      if (net?.source_net_id && port.source_port_id) {
+        const st = db.source_trace.list().find(
+          (s) => s.connected_source_net_ids?.includes(net.source_net_id) && s.connected_source_port_ids?.includes(port.source_port_id)
+        );
+        source_trace_id = st?.source_trace_id;
+      }
+      db.schematic_trace.insert({
+        source_trace_id,
+        edges,
+        junctions: []
+      });
+      db.schematic_port.update(port.schematic_port_id, { is_connected: true });
+    }
+  }
 };
 
 // lib/components/primitive-components/SilkscreenCircle.ts
 import { silkscreenCircleProps } from "@tscircuit/props";
 var SilkscreenCircle = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "pcb_silkscreen_circle_id", null);
-    __publicField(this, "isPcbPrimitive", true);
-  }
+  pcb_silkscreen_circle_id = null;
+  isPcbPrimitive = true;
   get config() {
     return {
       componentName: "SilkscreenCircle",
@@ -11711,11 +12476,8 @@ var SilkscreenCircle = class extends PrimitiveComponent2 {
 // lib/components/primitive-components/SilkscreenRect.ts
 import { silkscreenRectProps } from "@tscircuit/props";
 var SilkscreenRect = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "pcb_silkscreen_rect_id", null);
-    __publicField(this, "isPcbPrimitive", true);
-  }
+  pcb_silkscreen_rect_id = null;
+  isPcbPrimitive = true;
   get config() {
     return {
       componentName: "SilkscreenRect",
@@ -11759,11 +12521,8 @@ var SilkscreenRect = class extends PrimitiveComponent2 {
 // lib/components/primitive-components/SilkscreenLine.ts
 import { silkscreenLineProps } from "@tscircuit/props";
 var SilkscreenLine = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "pcb_silkscreen_line_id", null);
-    __publicField(this, "isPcbPrimitive", true);
-  }
+  pcb_silkscreen_line_id = null;
+  isPcbPrimitive = true;
   get config() {
     return {
       componentName: "SilkscreenLine",
@@ -11807,12 +12566,9 @@ var SilkscreenLine = class extends PrimitiveComponent2 {
 // lib/components/primitive-components/Via.ts
 import { viaProps } from "@tscircuit/props";
 var Via = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "pcb_via_id", null);
-    __publicField(this, "matchedPort", null);
-    __publicField(this, "isPcbPrimitive", true);
-  }
+  pcb_via_id = null;
+  matchedPort = null;
+  isPcbPrimitive = true;
   get config() {
     return {
       componentName: "Via",
@@ -12234,12 +12990,6 @@ var Crystal = class extends NormalComponent {
 // lib/components/normal-components/Transistor.ts
 import { transistorProps } from "@tscircuit/props";
 var Transistor = class extends NormalComponent {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "emitter", this.portMap.pin1);
-    __publicField(this, "collector", this.portMap.pin2);
-    __publicField(this, "base", this.portMap.pin3);
-  }
   get config() {
     const baseSymbolName = this.props.type === "npn" ? "npn_bipolar_transistor" : "pnp_bipolar_transistor";
     return {
@@ -12265,6 +13015,9 @@ var Transistor = class extends NormalComponent {
       additionalAliases: pinAliases
     });
   }
+  emitter = this.portMap.pin1;
+  collector = this.portMap.pin2;
+  base = this.portMap.pin3;
   doInitialCreateNetsFromProps() {
     this._createNetsFromProps([...this._getNetsFromConnectionsProp()]);
   }
@@ -12380,17 +13133,17 @@ var TestPoint = class extends NormalComponent {
     if (!footprintVariant && holeDiameter) {
       footprintVariant = "through_hole";
     }
-    footprintVariant ?? (footprintVariant = "through_hole");
-    padShape ?? (padShape = "circle");
+    footprintVariant ??= "through_hole";
+    padShape ??= "circle";
     if (footprintVariant === "pad") {
       if (padShape === "circle") {
-        padDiameter ?? (padDiameter = TESTPOINT_DEFAULTS.SMT_CIRCLE_DIAMETER);
+        padDiameter ??= TESTPOINT_DEFAULTS.SMT_CIRCLE_DIAMETER;
       } else if (padShape === "rect") {
-        width ?? (width = TESTPOINT_DEFAULTS.SMT_RECT_SIZE);
-        height ?? (height = width);
+        width ??= TESTPOINT_DEFAULTS.SMT_RECT_SIZE;
+        height ??= width;
       }
     } else if (footprintVariant === "through_hole") {
-      holeDiameter ?? (holeDiameter = TESTPOINT_DEFAULTS.HOLE_DIAMETER);
+      holeDiameter ??= TESTPOINT_DEFAULTS.HOLE_DIAMETER;
     }
     return {
       padShape,
@@ -12455,10 +13208,7 @@ var TestPoint = class extends NormalComponent {
 // lib/components/primitive-components/SchematicText.ts
 import { schematicTextProps } from "@tscircuit/props";
 var SchematicText = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "isSchematicPrimitive", true);
-  }
+  isSchematicPrimitive = true;
   get config() {
     return {
       componentName: "SchematicText",
@@ -12562,10 +13312,7 @@ function getTitleAnchorAndPosition({
 
 // lib/components/primitive-components/SchematicBox.ts
 var SchematicBox = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "isSchematicPrimitive", true);
-  }
+  isSchematicPrimitive = true;
   get config() {
     return {
       componentName: "SchematicBox",
@@ -12686,11 +13433,8 @@ var SchematicBox = class extends PrimitiveComponent2 {
 // lib/components/primitive-components/SchematicTable.ts
 import { schematicTableProps } from "@tscircuit/props";
 var SchematicTable = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "isSchematicPrimitive", true);
-    __publicField(this, "schematic_table_id", null);
-  }
+  isSchematicPrimitive = true;
+  schematic_table_id = null;
   get config() {
     return {
       componentName: "SchematicTable",
@@ -12818,10 +13562,7 @@ var SchematicTable = class extends PrimitiveComponent2 {
 // lib/components/primitive-components/SchematicRow.ts
 import { schematicRowProps } from "@tscircuit/props";
 var SchematicRow = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "isSchematicPrimitive", true);
-  }
+  isSchematicPrimitive = true;
   get config() {
     return {
       componentName: "SchematicRow",
@@ -12833,11 +13574,8 @@ var SchematicRow = class extends PrimitiveComponent2 {
 // lib/components/primitive-components/SchematicCell.ts
 import { schematicCellProps } from "@tscircuit/props";
 var SchematicCell = class extends PrimitiveComponent2 {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "isSchematicPrimitive", true);
-    __publicField(this, "canHaveTextChildren", true);
-  }
+  isSchematicPrimitive = true;
+  canHaveTextChildren = true;
   get config() {
     return {
       componentName: "SchematicCell",
@@ -12855,7 +13593,7 @@ import { identity as identity5 } from "transformation-matrix";
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.644",
+  version: "0.0.646",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -12885,8 +13623,8 @@ var package_default = {
   devDependencies: {
     "@biomejs/biome": "^1.8.3",
     "@tscircuit/capacity-autorouter": "^0.0.100",
-    "@tscircuit/circuit-json-util": "^0.0.65",
     "@tscircuit/checks": "^0.0.71",
+    "@tscircuit/circuit-json-util": "^0.0.65",
     "@tscircuit/footprinter": "^0.0.208",
     "@tscircuit/import-snippet": "^0.0.4",
     "@tscircuit/infgrid-ijump-astar": "^0.0.33",
@@ -12898,6 +13636,7 @@ var package_default = {
     "@tscircuit/schematic-autolayout": "^0.0.6",
     "@tscircuit/schematic-corpus": "^0.0.110",
     "@tscircuit/schematic-match-adapt": "^0.0.16",
+    "@tscircuit/schematic-trace-solver": "^0.0.12",
     "@tscircuit/simple-3d-svg": "^0.0.38",
     "@types/bun": "^1.2.16",
     "@types/debug": "^4.1.12",
@@ -12914,6 +13653,7 @@ var package_default = {
     "circuit-json-to-simple-3d": "^0.0.6",
     "circuit-to-svg": "^0.0.174",
     concurrently: "^9.1.2",
+    "connectivity-map": "^1.0.0",
     debug: "^4.3.6",
     "graphics-debug": "^0.0.60",
     howfat: "^0.3.8",
@@ -12962,33 +13702,33 @@ var package_default = {
 
 // lib/RootCircuit.ts
 var RootCircuit = class {
+  firstChild = null;
+  children;
+  db;
+  root = null;
+  isRoot = true;
+  schematicDisabled = false;
+  pcbDisabled = false;
+  pcbRoutingDisabled = false;
+  _featureMspSchematicTraceRouting = false;
+  /**
+   * The RootCircuit name is usually set by the platform, it's not required but
+   * if supplied can identify the circuit in certain effects, e.g. it is passed
+   * as the display_name parameter for autorouting effects.
+   */
+  name;
+  platform;
+  /**
+   * Optional URL pointing to where this project is hosted or documented.
+   * When provided it is stored in the source_project_metadata.project_url field
+   * of the generated Circuit JSON.
+   */
+  projectUrl;
+  _hasRenderedAtleastOnce = false;
   constructor({
     platform,
     projectUrl
   } = {}) {
-    __publicField(this, "firstChild", null);
-    __publicField(this, "children");
-    __publicField(this, "db");
-    __publicField(this, "root", null);
-    __publicField(this, "isRoot", true);
-    __publicField(this, "schematicDisabled", false);
-    __publicField(this, "pcbDisabled", false);
-    __publicField(this, "pcbRoutingDisabled", false);
-    /**
-     * The RootCircuit name is usually set by the platform, it's not required but
-     * if supplied can identify the circuit in certain effects, e.g. it is passed
-     * as the display_name parameter for autorouting effects.
-     */
-    __publicField(this, "name");
-    __publicField(this, "platform");
-    /**
-     * Optional URL pointing to where this project is hosted or documented.
-     * When provided it is stored in the source_project_metadata.project_url field
-     * of the generated Circuit JSON.
-     */
-    __publicField(this, "projectUrl");
-    __publicField(this, "_hasRenderedAtleastOnce", false);
-    __publicField(this, "_eventListeners", {});
     this.children = [];
     this.db = su5([]);
     this.root = this;
@@ -13024,7 +13764,7 @@ var RootCircuit = class {
       this.firstChild = this.children[0];
       return;
     }
-    const group = new Group({ subcircuit: true });
+    const group = new Group6({ subcircuit: true });
     group.parent = this;
     group.addAll(this.children);
     this.children = [group];
@@ -13110,6 +13850,7 @@ var RootCircuit = class {
     this._guessRootComponent();
     return this.firstChild?.selectOne(selector, opts) ?? null;
   }
+  _eventListeners = {};
   emit(event, ...args) {
     if (!this._eventListeners[event]) return;
     for (const listener of this._eventListeners[event]) {
@@ -13363,7 +14104,7 @@ export {
   FabricationNoteText,
   Footprint,
   Fuse,
-  Group,
+  Group6 as Group,
   Hole,
   Inductor,
   Jumper,