@tscircuit/core 0.0.645 → 0.0.646

package/dist/index.d.ts

@@ -202,6 +202,7 @@ declare class RootCircuit {
     schematicDisabled: boolean;
     pcbDisabled: boolean;
     pcbRoutingDisabled: boolean;
+    _featureMspSchematicTraceRouting: boolean;
     /**
      * 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
@@ -1125,6 +1126,7 @@ declare class Group<Props extends z.ZodType<any, any, any> = typeof groupProps>
     _runLocalAutorouting(): Promise<void>;
     _startAsyncAutorouting(): void;
     doInitialPcbTraceRender(): void;
+    doInitialSchematicTraceRender(): void;
     updatePcbTraceRender(): void;
     _updatePcbTraceRenderFromSimpleRouteJson(): void;
     _updatePcbTraceRenderFromPcbTraces(): void;

package/dist/index.js

@@ -23,7 +23,7 @@ __export(components_exports, {
   FabricationNoteText: () => FabricationNoteText,
   Footprint: () => Footprint,
   Fuse: () => Fuse,
-  Group: () => Group,
+  Group: () => Group6,
   Hole: () => Hole,
   Inductor: () => Inductor,
   Jumper: () => Jumper,
@@ -4197,7 +4197,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);
 };
@@ -5091,6 +5091,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;
@@ -7219,7 +7220,7 @@ 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
@@ -8024,7 +8025,7 @@ function convertTreeToInputProblem(tree, db, group) {
     netMap: {},
     pinStrongConnMap: {},
     netConnMap: {},
-    chipGap: 0.4,
+    chipGap: 0.6,
     partitionGap: 1.2
   };
   debug5(
@@ -9501,7 +9502,751 @@ var Group_doInitialPcbLayoutFlex = (group) => {
 
 // lib/components/primitive-components/Group/Group.ts
 import { convertSrjToGraphicsObject } from "@tscircuit/capacity-autorouter";
-var Group = class extends NormalComponent {
+
+// 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 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 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 {
   constructor() {
     super(...arguments);
     __publicField(this, "pcb_group_id", null);
@@ -9669,20 +10414,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 +10543,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 +10576,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 +10637,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 +10674,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,7 +10985,7 @@ import {
   checkEachPcbPortConnectedToPcbTraces,
   checkEachPcbTraceNonOverlapping
 } from "@tscircuit/checks";
-var Board = class extends Group {
+var Board = class extends Group6 {
   constructor() {
     super(...arguments);
     __publicField(this, "pcb_board_id", null);
@@ -11413,7 +12161,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 +12172,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,
@@ -12855,7 +13603,7 @@ import { identity as identity5 } from "transformation-matrix";
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.644",
+  version: "0.0.645",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -12885,8 +13633,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 +13646,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 +13663,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",
@@ -12974,6 +13724,7 @@ var RootCircuit = class {
     __publicField(this, "schematicDisabled", false);
     __publicField(this, "pcbDisabled", false);
     __publicField(this, "pcbRoutingDisabled", false);
+    __publicField(this, "_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
@@ -13024,7 +13775,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];
@@ -13363,7 +14114,7 @@ export {
   FabricationNoteText,
   Footprint,
   Fuse,
-  Group,
+  Group6 as Group,
   Hole,
   Inductor,
   Jumper,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.645",
+  "version": "0.0.646",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -31,8 +31,8 @@
   "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",
@@ -44,6 +44,7 @@
     "@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",
@@ -60,6 +61,7 @@
     "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",