@tscircuit/core 0.0.330 → 0.0.332

package/dist/index.d.ts

@@ -1,14 +1,15 @@
 import * as _tscircuit_props from '@tscircuit/props';
-import { subcircuitGroupProps, traceProps, SupplierPartNumbers, SchematicPortArrangement, groupProps, AutorouterConfig, boardProps, capacitorProps, chipProps, diodeProps, jumperProps, ledProps, powerSourceProps, resistorProps, constraintProps, fabricationNotePathProps, fabricationNoteTextProps, footprintProps, subcircuitProps, holeProps, pcbKeepoutProps, netAliasProps, platedHoleProps, silkscreenCircleProps, silkscreenPathProps, silkscreenRectProps, silkscreenTextProps, silkscreenLineProps, smtPadProps, traceHintProps, viaProps, batteryProps, pinHeaderProps, resonatorProps, inductorProps, potentiometerProps, pushButtonProps, crystalProps, transistorProps, mosfetProps, switchProps, CapacitorProps, ChipProps, ResistorProps, ManualEditEvent, manual_edits_file } from '@tscircuit/props';
+import { subcircuitGroupProps, AutorouterConfig, traceProps, SupplierPartNumbers, SchematicPortArrangement, groupProps, boardProps, capacitorProps, chipProps, diodeProps, jumperProps, ledProps, powerSourceProps, resistorProps, constraintProps, fabricationNotePathProps, fabricationNoteTextProps, footprintProps, subcircuitProps, holeProps, pcbKeepoutProps, netAliasProps, platedHoleProps, silkscreenCircleProps, silkscreenPathProps, silkscreenRectProps, silkscreenTextProps, silkscreenLineProps, smtPadProps, traceHintProps, viaProps, batteryProps, pinHeaderProps, resonatorProps, inductorProps, potentiometerProps, pushButtonProps, crystalProps, transistorProps, mosfetProps, switchProps, CapacitorProps, ChipProps, ResistorProps, ManualEditEvent, manual_edits_file } from '@tscircuit/props';
 import React, { ReactElement, DetailedHTMLProps, SVGProps } from 'react';
 export { createElement } from 'react';
 import * as zod from 'zod';
 import { z, ZodType } from 'zod';
 import { symbols, SchSymbol, BaseSymbolName } from 'schematic-symbols';
-import { PcbTraceError, PcbPlacementError, PcbManualEditConflictError, LayerRef, AnyCircuitElement, AnySourceComponent, PcbTrace, RouteHintPoint, CircuitJson } from 'circuit-json';
+import { PcbTraceError, PcbPlacementError, PcbManualEditConflictError, LayerRef, AnyCircuitElement, AnySourceComponent, PcbTraceRoutePoint, PcbTrace, RouteHintPoint, CircuitJson } from 'circuit-json';
 import { Matrix } from 'transformation-matrix';
 import { SoupUtilObjects } from '@tscircuit/soup-util';
 import * as _tscircuit_layout from '@tscircuit/layout';
+import { ConnectivityMap } from 'circuit-json-to-connectivity-map';
 
 declare const orderedRenderPhases: readonly ["ReactSubtreesRender", "InitializePortsFromChildren", "CreateNetsFromProps", "CreateTracesFromProps", "CreateTraceHintsFromProps", "SourceRender", "SourceParentAttachment", "PortMatching", "SourceTraceRender", "SourceAddConnectivityMapKey", "SchematicComponentRender", "SchematicPortRender", "SchematicLayout", "SchematicTraceRender", "PcbComponentRender", "PcbPrimitiveRender", "PcbFootprintLayout", "PcbPortRender", "PcbPortAttachment", "PcbLayout", "PcbComponentSizeCalculation", "PcbBoardAutoSize", "PcbTraceRender", "PcbTraceHintRender", "PcbRouteNetIslands", "CadModelRender", "PartsEngineRender"];
 type RenderPhase = (typeof orderedRenderPhases)[number];
@@ -103,7 +104,7 @@ interface SchematicBoxDimensions {
     };
 }
 
-type RootCircuitEventName = "asyncEffect:start" | "asyncEffect:end" | "renderable:renderLifecycle:anyEvent" | `renderable:renderLifecycle:${RenderPhase}:start` | `renderable:renderLifecycle:${RenderPhase}:end` | "external:evalError";
+type RootCircuitEventName = "asyncEffect:start" | "asyncEffect:end" | "renderable:renderLifecycle:anyEvent" | `renderable:renderLifecycle:${RenderPhase}:start` | `renderable:renderLifecycle:${RenderPhase}:end` | "external:evalError" | "autorouting:start" | "autorouting:end" | "autorouting:progress";
 declare class RootCircuit {
     firstChild: PrimitiveComponent | null;
     children: PrimitiveComponent[];
@@ -169,6 +170,7 @@ declare const Circuit: typeof RootCircuit;
 interface ISubcircuit extends PrimitiveComponent {
     _shouldUseTraceByTraceRouting(): boolean;
     _parsedProps: z.infer<typeof subcircuitGroupProps>;
+    _getAutorouterConfig(): AutorouterConfig;
     subcircuit_id: string | null;
 }
 
@@ -391,6 +393,7 @@ declare class Net extends PrimitiveComponent<typeof netProps> {
     };
     getPortSelector(): string;
     doInitialSourceRender(): void;
+    doInitialSourceParentAttachment(): void;
     /**
      * Get all ports connected to this net.
      *
@@ -412,6 +415,8 @@ declare class Net extends PrimitiveComponent<typeof netProps> {
      * Sometimes this phase doesn't find any net islands if the autorouter did
      * a good job and connected the islands. In some sense this is a "backup"
      * routing phase for autorouters that don't care about connecting nets.
+     *
+     * This should only run if the autorouter is sequential-trace
      */
     doInitialPcbRouteNetIslands(): void;
     renderError(message: Parameters<typeof PrimitiveComponent.prototype.renderError>[0]): void;
@@ -662,6 +667,7 @@ declare class Trace extends PrimitiveComponent<typeof traceProps> implements Tra
     _isExplicitlyConnectedToNet(net: Net): boolean;
     doInitialCreateNetsFromProps(): void;
     doInitialSourceTraceRender(): void;
+    _insertErrorIfTraceIsOutsideBoard(mergedRoute: PcbTraceRoutePoint[], ports: Port[]): void;
     doInitialPcbTraceRender(): void;
     _doInitialSchematicTraceRenderWithDisplayLabel(): void;
     private _isSymbolToChipConnection;
@@ -902,6 +908,7 @@ declare class NormalComponent<ZodProps extends ZodType = any, PortNames extends
 type SimplifiedPcbTrace = {
     type: "pcb_trace";
     pcb_trace_id: string;
+    connection_name?: string;
     route: Array<{
         route_type: "wire";
         x: number;
@@ -965,12 +972,15 @@ declare class Group<Props extends z.ZodType<any, any, any> = typeof groupProps>
     doInitialSourceParentAttachment(): void;
     doInitialPcbComponentRender(): void;
     doInitialCreateTraceHintsFromProps(): void;
-    _getSimpleRouteJsonFromPcbTraces(): SimpleRouteJson;
     doInitialSourceAddConnectivityMapKey(): void;
     _areChildSubcircuitsRouted(): boolean;
     _shouldRouteAsync(): boolean;
     _hasTracesToRoute(): boolean;
     _runEffectMakeHttpAutoroutingRequest(): Promise<void>;
+    /**
+     * Run local autorouting using the CapacityMeshAutorouter
+     */
+    _runLocalCapacityMeshAutorouting(): Promise<void>;
     _startAsyncAutorouting(): void;
     doInitialPcbTraceRender(): void;
     updatePcbTraceRender(): void;
@@ -10714,10 +10724,15 @@ declare const applyEditEventsToManualEditsFile: ({ circuitJson, editEvents, manu
 /**
  * This function can only be called in the PcbTraceRender phase or later
  */
-declare const getSimpleRouteJsonFromCircuitJson: ({ circuitJson, minTraceWidth, }: {
-    circuitJson: AnyCircuitElement[];
+declare const getSimpleRouteJsonFromCircuitJson: ({ db, circuitJson, subcircuit_id, minTraceWidth, }: {
+    db?: SoupUtilObjects;
+    circuitJson?: AnyCircuitElement[];
+    subcircuit_id?: string | null;
     minTraceWidth?: number;
-}) => SimpleRouteJson;
+}) => {
+    simpleRouteJson: SimpleRouteJson;
+    connMap: ConnectivityMap;
+};
 
 type RenderEvent = {
     type: string;
@@ -10736,7 +10751,7 @@ declare const getPhaseTimingsFromRenderEvents: (renderEvents: RenderEvent[]) =>
 type Nums16 = "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "10" | "11" | "12" | "13" | "14" | "15" | "16";
 type Nums40 = "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "10" | "11" | "12" | "13" | "14" | "15" | "16" | "17" | "18" | "19" | "20" | "21" | "22" | "23" | "24" | "25" | "26" | "27" | "28" | "29" | "30" | "31" | "32" | "33" | "34" | "35" | "36" | "37" | "38" | "39" | "40";
 type PinNumbers100 = "pin1" | "pin2" | "pin3" | "pin4" | "pin5" | "pin6" | "pin7" | "pin8" | "pin9" | "pin10" | "pin11" | "pin12" | "pin13" | "pin14" | "pin15" | "pin16" | "pin17" | "pin18" | "pin19" | "pin20" | "pin21" | "pin22" | "pin23" | "pin24" | "pin25" | "pin26" | "pin27" | "pin28" | "pin29" | "pin30" | "pin31" | "pin32" | "pin33" | "pin34" | "pin35" | "pin36" | "pin37" | "pin38" | "pin39" | "pin40" | "pin41" | "pin42" | "pin43" | "pin44" | "pin45" | "pin46" | "pin47" | "pin48" | "pin49" | "pin50" | "pin51" | "pin52" | "pin53" | "pin54" | "pin55" | "pin56" | "pin57" | "pin58" | "pin59" | "pin60" | "pin61" | "pin62" | "pin63" | "pin64" | "pin65" | "pin66" | "pin67" | "pin68" | "pin69" | "pin70" | "pin71" | "pin72" | "pin73" | "pin74" | "pin75" | "pin76" | "pin77" | "pin78" | "pin79" | "pin80" | "pin81" | "pin82" | "pin83" | "pin84" | "pin85" | "pin86" | "pin87" | "pin88" | "pin89" | "pin90" | "pin91" | "pin92" | "pin93" | "pin94" | "pin95" | "pin96" | "pin97" | "pin98" | "pin99" | "pin100";
-type CommonPinNames = "pos" | "neg" | "V5" | "V3_3" | "VCC" | "VDD" | "GND" | `D${Nums40}` | `GP${Nums40}` | `GPIO${Nums40}` | "DP" | "DN" | "VIN" | "VOUT" | "VREF" | "VIN" | "VOUT" | "VREF" | "VIN" | "VOUT" | "VREF" | "OUT" | "DISCH" | "EN" | "IN" | "CLK" | "DATA" | "THRES" | "TRIG" | "RESET" | `A${Nums40}` | `B${Nums40}` | PinNumbers100;
+type CommonPinNames = "pos" | "neg" | "V5" | "V3_3" | "PWR" | "VCC" | "VDD" | "GND" | `D${Nums40}` | `GP${Nums40}` | `GPIO${Nums40}` | "DP" | "DN" | "VIN" | "VOUT" | "VREF" | "VIN" | "VOUT" | "VREF" | "VIN" | "VOUT" | "VREF" | "OUT" | "DISCH" | "EN" | "IN" | "CLK" | "DATA" | "THRES" | "TRIG" | "RESET" | `A${Nums40}` | `B${Nums40}` | PinNumbers100;
 type TransistorPinNames = "base" | "collector" | "emitter";
 
 type NonPolarizedSel = Record<`R${Nums40}`, {
@@ -10761,12 +10776,15 @@ type PolarizedSel = Record<`C${Nums40}` | `L${Nums40}` | `LED${Nums40}` | `D${Nu
     pos: string;
     neg: string;
 }>;
+type CommonNetNames = "VCC" | "GND" | "VDD" | "PWR" | "V5" | "V3_3";
 type TransistorSel = Record<`Q${Nums40}`, Record<TransistorPinNames, string>>;
-type JumperSel = Record<`J${Nums40}`, Record<PinNumbers100, string>>;
+type JumperSel = Record<`J${Nums40}`, Record<PinNumbers100 | CommonPinNames, string>>;
 type ChipSel = Record<`U${Nums40}`, Record<CommonPinNames, string>>;
-type NetSel = Record<"net", Record<"VCC" | "GND" | "VDD", string>>;
+type NetSel = Record<"net", Record<CommonNetNames, string>>;
 type ConnectionSel = Record<`CN${Nums40}`, Record<CommonPinNames, string>>;
-type Sel = NonPolarizedSel & PolarizedSel & TransistorSel & JumperSel & ChipSel & SwSel & NetSel & ConnectionSel;
+type SubcircuitSel = Record<"subcircuit", Record<`S${Nums40}`, SelWithoutSubcircuit>>;
+type SelWithoutSubcircuit = NonPolarizedSel & PolarizedSel & TransistorSel & JumperSel & ChipSel & SwSel & NetSel & ConnectionSel;
+type Sel = SubcircuitSel & SelWithoutSubcircuit;
 declare const sel: Sel;
 
 interface TscircuitElements {

package/dist/index.js

@@ -1192,6 +1192,14 @@ var Net = class extends PrimitiveComponent {
     });
     this.source_net_id = net.source_net_id;
   }
+  doInitialSourceParentAttachment() {
+    const subcircuit = this.getSubcircuit();
+    if (!subcircuit) return;
+    const { db } = this.root;
+    db.source_net.update(this.source_net_id, {
+      subcircuit_id: subcircuit.subcircuit_id
+    });
+  }
   /**
    * Get all ports connected to this net.
    *
@@ -1235,10 +1243,14 @@ var Net = class extends PrimitiveComponent {
    * Sometimes this phase doesn't find any net islands if the autorouter did
    * a good job and connected the islands. In some sense this is a "backup"
    * routing phase for autorouters that don't care about connecting nets.
+   *
+   * This should only run if the autorouter is sequential-trace
    */
   doInitialPcbRouteNetIslands() {
     if (this.root?.pcbDisabled) return;
     if (this.getSubcircuit()._parsedProps.routingDisabled) return;
+    if (this.getSubcircuit()._getAutorouterConfig().groupMode !== "sequential-trace")
+      return;
     const { db } = this.root;
     const { _parsedProps: props } = this;
     const traces = this._getAllDirectlyConnectedTraces().filter(
@@ -1335,8 +1347,12 @@ var Net = class extends PrimitiveComponent {
 var createNetsFromProps = (component, props) => {
   for (const prop of props) {
     if (typeof prop === "string" && prop.startsWith("net.")) {
-      if (!component.getSubcircuit().selectOne(prop)) {
-        component.getSubcircuit().add(new Net({ name: prop.split("net.")[1] }));
+      const subcircuit = component.getSubcircuit();
+      if (!subcircuit.selectOne(prop)) {
+        const net = new Net({
+          name: prop.split("net.")[1]
+        });
+        subcircuit.add(net);
       }
     }
   }
@@ -2284,7 +2300,8 @@ var Port = class extends PrimitiveComponent {
       );
     }
     db.source_port.update(this.source_port_id, {
-      source_component_id: this.parent?.source_component_id
+      source_component_id: this.parent?.source_component_id,
+      subcircuit_id: this.getSubcircuit()?.subcircuit_id
     });
     this.source_component_id = this.parent?.source_component_id;
   }
@@ -2967,6 +2984,7 @@ var DirectLineRouter = class {
       const trace = {
         type: "pcb_trace",
         pcb_trace_id: "",
+        connection_name: connection.name,
         route: [
           {
             route_type: "wire",
@@ -3634,6 +3652,22 @@ var pushEdgesOfSchematicTraceToPreventOverlap = ({
   }
 };
 
+// lib/utils/is-route-outside-board.ts
+var isRouteOutsideBoard = (mergedRoute, { db }) => {
+  const pcbBoard = db.pcb_board.list()[0];
+  if (pcbBoard.outline) {
+    return true;
+  }
+  const boardWidth = pcbBoard.width;
+  const boardHeight = pcbBoard.height;
+  const boardCenterX = pcbBoard.center.x;
+  const boardCenterY = pcbBoard.center.y;
+  const outsideBoard = mergedRoute.some((point) => {
+    return point.x < boardCenterX - boardWidth / 2 || point.y < boardCenterY - boardHeight / 2 || point.x > boardCenterX + boardWidth / 2 || point.y > boardCenterY + boardHeight / 2;
+  });
+  return outsideBoard;
+};
+
 // lib/components/primitive-components/Trace/Trace.ts
 var portToObjective = (port) => {
   const portPosition = port._getGlobalPcbPositionAfterLayout();
@@ -3790,6 +3824,20 @@ searched component ${targetComponent.getString()}, which has ports: ${targetComp
     });
     this.source_trace_id = trace.source_trace_id;
   }
+  _insertErrorIfTraceIsOutsideBoard(mergedRoute, ports) {
+    const { db } = this.root;
+    const isOutsideBoard = isRouteOutsideBoard(mergedRoute, { db });
+    if (isOutsideBoard) {
+      db.pcb_trace_error.insert({
+        error_type: "pcb_trace_error",
+        source_trace_id: this.source_trace_id,
+        message: `Trace ${this.getString()} routed outside the board boundaries.`,
+        pcb_trace_id: this.pcb_trace_id,
+        pcb_component_ids: [],
+        pcb_port_ids: ports.map((p) => p.pcb_port_id)
+      });
+    }
+  }
   doInitialPcbTraceRender() {
     if (this.root?.pcbDisabled) return;
     const { db } = this.root;
@@ -4061,6 +4109,7 @@ searched component ${targetComponent.getString()}, which has ports: ${targetComp
         });
       }
     }
+    this._insertErrorIfTraceIsOutsideBoard(mergedRoute, ports);
   }
   _doInitialSchematicTraceRenderWithDisplayLabel() {
     if (this.root?.schematicDisabled) return;
@@ -4658,7 +4707,6 @@ var NormalComponent = class extends PrimitiveComponent {
     if (symbol) {
       const schematic_component2 = db.schematic_component.insert({
         center,
-        rotation: props.schRotation ?? 0,
         size: symbol.size,
         source_component_id: this.source_component_id,
         symbol_name,
@@ -5102,64 +5150,156 @@ import {
   groupProps
 } from "@tscircuit/props";
 import * as SAL from "@tscircuit/schematic-autolayout";
-import "circuit-json";
-import { ConnectivityMap } from "circuit-json-to-connectivity-map";
-import Debug5 from "debug";
 
-// lib/utils/autorouting/getSimpleRouteJsonFromTracesAndDb.ts
-import { getObstaclesFromSoup as getObstaclesFromSoup2 } from "@tscircuit/infgrid-ijump-astar";
-var getSimpleRouteJsonFromTracesAndDb = ({
-  db,
-  traces,
-  minTraceWidth = 0.1
-}) => {
-  const obstacles = getObstaclesFromSoup2([
-    ...db.pcb_component.list(),
-    ...db.pcb_smtpad.list(),
-    ...db.pcb_plated_hole.list()
-  ]);
-  const allPoints = obstacles.flatMap((o) => [
-    {
-      x: o.center.x - o.width / 2,
-      y: o.center.y - o.height / 2
-    },
-    {
-      x: o.center.x + o.width / 2,
-      y: o.center.y + o.height / 2
-    }
-  ]);
-  const bounds = {
-    minX: Math.min(...allPoints.map((p) => p.x)) - 1,
-    maxX: Math.max(...allPoints.map((p) => p.x)) + 1,
-    minY: Math.min(...allPoints.map((p) => p.y)) - 1,
-    maxY: Math.max(...allPoints.map((p) => p.y)) + 1
-  };
-  const connections = traces.map((trace) => {
-    const connectedPorts = trace._findConnectedPorts();
-    if (!connectedPorts.allPortsFound || connectedPorts.ports.length < 2)
-      return null;
-    return {
-      name: trace.source_trace_id ?? "",
-      pointsToConnect: connectedPorts.ports.map((port) => {
-        const pos = port._getGlobalPcbPositionBeforeLayout();
-        return {
-          x: pos.x,
-          y: pos.y,
-          layer: port.getAvailablePcbLayers()[0] ?? "top"
-        };
-      })
-    };
-  }).filter((c) => c !== null);
-  return {
-    bounds,
-    obstacles: [],
-    connections,
-    layerCount: 2,
-    minTraceWidth
+// 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 = {}) {
+    this.input = input;
+    const { capacityDepth, targetMinCapacity, stepDelay = 0 } = options;
+    this.solver = new CapacityMeshSolver(input, {
+      capacityDepth,
+      targetMinCapacity
+    });
+    this.stepDelay = stepDelay;
+  }
+  /**
+   * Start the autorouting process asynchronously
+   * This will emit progress events during routing and a complete event when done
+   */
+  start() {
+    if (this.isRouting) return;
+    this.isRouting = true;
+    this.cycleCount = 0;
+    this.runCycleAndQueueNextCycle();
+  }
+  /**
+   * Execute the next routing step and schedule the following one if needed
+   */
+  runCycleAndQueueNextCycle() {
+    if (!this.isRouting) return;
+    try {
+      if (this.solver.solved || this.solver.failed) {
+        if (this.solver.failed) {
+          this.emitEvent({
+            type: "error",
+            error: new Error(this.solver.error || "Routing failed")
+          });
+        } else {
+          this.emitEvent({
+            type: "complete",
+            traces: this.solver.getOutputSimpleRouteJson().traces || []
+          });
+        }
+        this.isRouting = false;
+        return;
+      }
+      const startTime = performance.now();
+      const startIterations = this.solver.iterations;
+      while (performance.now() - startTime < 10 && !this.solver.failed && !this.solver.solved) {
+        this.solver.step();
+      }
+      this.cycleCount++;
+      const debugGraphics = this.solver.activeSolver?.visualize() || void 0;
+      const progress = this.solver.progress;
+      this.emitEvent({
+        type: "progress",
+        steps: this.cycleCount,
+        progress,
+        phase: this.solver.getCurrentPhase(),
+        debugGraphics
+      });
+      if (this.stepDelay > 0) {
+        this.timeoutId = setTimeout(
+          () => this.runCycleAndQueueNextCycle(),
+          this.stepDelay
+        );
+      } else {
+        this.timeoutId = setTimeout(
+          () => this.runCycleAndQueueNextCycle(),
+          0
+        );
+      }
+    } catch (error) {
+      this.emitEvent({
+        type: "error",
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+      this.isRouting = false;
+    }
+  }
+  /**
+   * Stop the routing process if it's in progress
+   */
+  stop() {
+    if (!this.isRouting) return;
+    this.isRouting = false;
+    if (this.timeoutId !== void 0) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = void 0;
+    }
+  }
+  on(event, callback) {
+    if (event === "complete") {
+      this.eventHandlers.complete.push(
+        callback
+      );
+    } else if (event === "error") {
+      this.eventHandlers.error.push(
+        callback
+      );
+    } else if (event === "progress") {
+      this.eventHandlers.progress.push(
+        callback
+      );
+    }
+  }
+  /**
+   * Emit an event to all registered handlers
+   */
+  emitEvent(event) {
+    if (event.type === "complete") {
+      for (const handler of this.eventHandlers.complete) {
+        handler(event);
+      }
+    } else if (event.type === "error") {
+      for (const handler of this.eventHandlers.error) {
+        handler(event);
+      }
+    } else if (event.type === "progress") {
+      for (const handler of this.eventHandlers.progress) {
+        handler(event);
+      }
+    }
+  }
+  /**
+   * Solve the routing problem synchronously
+   * @returns Array of routed traces
+   */
+  solveSync() {
+    this.solver.solve();
+    if (this.solver.failed) {
+      throw new Error(this.solver.error || "Routing failed");
+    }
+    return this.solver.getOutputSimpleRouteJson().traces || [];
+  }
 };
 
 // lib/components/primitive-components/Group/Group.ts
+import "circuit-json";
+import { ConnectivityMap as ConnectivityMap2 } from "circuit-json-to-connectivity-map";
+import Debug5 from "debug";
 import "zod";
 
 // lib/components/primitive-components/TraceHint.ts
@@ -5223,6 +5363,220 @@ var TraceHint = class extends PrimitiveComponent {
   }
 };
 
+// lib/utils/edit-events/apply-edit-events-to-manual-edits-file.ts
+import "zod";
+import { su } from "@tscircuit/soup-util";
+var applyEditEventsToManualEditsFile = ({
+  circuitJson,
+  editEvents,
+  manualEditsFile
+}) => {
+  const updatedManualEditsFile = {
+    ...manualEditsFile,
+    schematic_placements: [...manualEditsFile.schematic_placements ?? []]
+  };
+  for (const editEvent of editEvents) {
+    if (editEvent.edit_event_type === "edit_schematic_component_location") {
+      const { schematic_component_id, new_center } = editEvent;
+      const schematic_component2 = su(circuitJson).schematic_component.get(
+        schematic_component_id
+      );
+      if (!schematic_component2) continue;
+      const source_component = su(circuitJson).source_component.get(
+        schematic_component2.source_component_id
+      );
+      if (!source_component) continue;
+      const existingPlacementIndex = updatedManualEditsFile.schematic_placements?.findIndex(
+        (p) => p.selector === source_component.name
+      );
+      const newPlacement = {
+        selector: source_component.name,
+        center: new_center,
+        relative_to: "group_center"
+      };
+      if (existingPlacementIndex >= 0) {
+        updatedManualEditsFile.schematic_placements[existingPlacementIndex] = newPlacement;
+      } else {
+        updatedManualEditsFile.schematic_placements.push(newPlacement);
+      }
+    }
+  }
+  return updatedManualEditsFile;
+};
+
+// lib/utils/autorouting/getSimpleRouteJsonFromCircuitJson.ts
+import { getObstaclesFromSoup as getObstaclesFromSoup2 } from "@tscircuit/infgrid-ijump-astar";
+import { su as su2 } from "@tscircuit/soup-util";
+import {
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson2
+} from "circuit-json-to-connectivity-map";
+
+// lib/utils/autorouting/getAncestorSubcircuitIds.ts
+var getDescendantSubcircuitIds = (db, root_subcircuit_id) => {
+  const groups = db.source_group.list();
+  const result = [];
+  const findDescendants = (parentId) => {
+    const children = groups.filter(
+      (group) => group.parent_subcircuit_id === parentId
+    );
+    for (const child of children) {
+      if (child.subcircuit_id) {
+        result.push(child.subcircuit_id);
+        findDescendants(child.subcircuit_id);
+      }
+    }
+  };
+  findDescendants(root_subcircuit_id);
+  return result;
+};
+
+// lib/utils/autorouting/getSimpleRouteJsonFromCircuitJson.ts
+var getSimpleRouteJsonFromCircuitJson = ({
+  db,
+  circuitJson,
+  subcircuit_id,
+  minTraceWidth = 0.1
+}) => {
+  if (!db && circuitJson) {
+    db = su2(circuitJson);
+  }
+  if (!db) {
+    throw new Error("db or circuitJson is required");
+  }
+  const relevantSubcircuitIds = subcircuit_id ? /* @__PURE__ */ new Set([subcircuit_id]) : null;
+  if (subcircuit_id) {
+    const descendantSubcircuitIds = getDescendantSubcircuitIds(
+      db,
+      subcircuit_id
+    );
+    for (const id of descendantSubcircuitIds) {
+      relevantSubcircuitIds.add(id);
+    }
+  }
+  const subcircuitElements = (circuitJson ?? db.toArray()).filter(
+    (e) => !subcircuit_id || "subcircuit_id" in e && relevantSubcircuitIds.has(e.subcircuit_id)
+  );
+  const board = db.pcb_board.list()[0];
+  db = su2(subcircuitElements);
+  const connMap = getFullConnectivityMapFromCircuitJson2(subcircuitElements);
+  const obstacles = getObstaclesFromSoup2(
+    [
+      ...db.pcb_component.list(),
+      ...db.pcb_smtpad.list(),
+      ...db.pcb_plated_hole.list()
+    ].filter(
+      (e) => !subcircuit_id || relevantSubcircuitIds?.has(e.subcircuit_id)
+    ),
+    connMap
+  );
+  const allPoints = obstacles.flatMap((o) => [
+    {
+      x: o.center.x - o.width / 2,
+      y: o.center.y - o.height / 2
+    },
+    {
+      x: o.center.x + o.width / 2,
+      y: o.center.y + o.height / 2
+    }
+  ]);
+  let bounds;
+  if (board) {
+    bounds = {
+      minX: board.center.x - board.width / 2,
+      maxX: board.center.x + board.width / 2,
+      minY: board.center.y - board.height / 2,
+      maxY: board.center.y + board.height / 2
+    };
+  } else {
+    bounds = {
+      minX: Math.min(...allPoints.map((p) => p.x)) - 1,
+      maxX: Math.max(...allPoints.map((p) => p.x)) + 1,
+      minY: Math.min(...allPoints.map((p) => p.y)) - 1,
+      maxY: Math.max(...allPoints.map((p) => p.y)) + 1
+    };
+  }
+  const directTraceConnections = db.source_trace.list().map((trace) => {
+    const connectedPorts = trace.connected_source_port_ids.map((id) => {
+      const source_port = db.source_port.get(id);
+      const pcb_port = db.pcb_port.getWhere({ source_port_id: id });
+      return {
+        ...source_port,
+        ...pcb_port
+      };
+    });
+    if (connectedPorts.length < 2) return null;
+    return {
+      name: connMap.getNetConnectedToId(trace.source_trace_id) ?? trace.source_trace_id ?? "",
+      source_trace_id: trace.source_trace_id,
+      pointsToConnect: connectedPorts.map((port) => {
+        return {
+          x: port.x,
+          y: port.y,
+          layer: port.layers?.[0] ?? "top"
+        };
+      })
+    };
+  }).filter((c) => c !== null);
+  const source_nets = db.source_net.list().filter(
+    (e) => !subcircuit_id || relevantSubcircuitIds?.has(e.subcircuit_id)
+  );
+  const connectionsFromNets = [];
+  for (const net of source_nets) {
+    const connectedSourceTraces = db.source_trace.list().filter((st) => st.connected_source_net_ids?.includes(net.source_net_id));
+    connectionsFromNets.push({
+      name: connMap.getNetConnectedToId(net.source_net_id) ?? net.source_net_id,
+      pointsToConnect: connectedSourceTraces.flatMap((st) => {
+        const pcb_ports = db.pcb_port.list().filter(
+          (p) => st.connected_source_port_ids.includes(p.source_port_id)
+        );
+        return pcb_ports.map((p) => ({
+          x: p.x,
+          y: p.y,
+          layer: p.layers?.[0] ?? "top",
+          pcb_port_id: p.pcb_port_id
+        }));
+      })
+    });
+  }
+  return {
+    simpleRouteJson: {
+      bounds,
+      obstacles,
+      connections: [...directTraceConnections, ...connectionsFromNets],
+      // TODO add traces so that we don't run into things routed by another
+      // subcircuit
+      layerCount: 2,
+      minTraceWidth
+    },
+    connMap
+  };
+};
+
+// lib/utils/render-events/getPhaseTimingsFromRenderEvents.ts
+var getPhaseTimingsFromRenderEvents = (renderEvents) => {
+  const phaseTimings = {};
+  if (!renderEvents) return phaseTimings;
+  for (const renderPhase of orderedRenderPhases) {
+    phaseTimings[renderPhase] = 0;
+  }
+  const startEvents = /* @__PURE__ */ new Map();
+  for (const event of renderEvents) {
+    const [, , phase, eventType] = event.type.split(":");
+    if (eventType === "start") {
+      startEvents.set(`${phase}:${event.renderId}`, event);
+      continue;
+    }
+    if (eventType === "end") {
+      const startEvent = startEvents.get(`${phase}:${event.renderId}`);
+      if (startEvent) {
+        const duration = event.createdAt - startEvent.createdAt;
+        phaseTimings[phase] = (phaseTimings[phase] || 0) + duration;
+      }
+    }
+  }
+  return phaseTimings;
+};
+
 // lib/components/primitive-components/Group/Group.ts
 var Group = class extends NormalComponent {
   pcb_group_id = null;
@@ -5288,20 +5642,11 @@ var Group = class extends NormalComponent {
       );
     }
   }
-  _getSimpleRouteJsonFromPcbTraces() {
-    const traces = this.selectAll("trace");
-    const { db } = this.root;
-    return getSimpleRouteJsonFromTracesAndDb({
-      db,
-      traces,
-      minTraceWidth: this._parsedProps.minTraceWidth ?? 0.1
-    });
-  }
   doInitialSourceAddConnectivityMapKey() {
     if (!this.isSubcircuit) return;
     const { db } = this.root;
     const traces = this.selectAll("trace");
-    const connMap = new ConnectivityMap({});
+    const connMap = new ConnectivityMap2({});
     connMap.addConnections(
       traces.map((t) => {
         const source_trace = db.source_trace.get(
@@ -5339,9 +5684,10 @@ var Group = class extends NormalComponent {
   }
   _shouldRouteAsync() {
     const autorouter = this._getAutorouterConfig();
-    if (autorouter.local) return false;
     if (autorouter.groupMode === "sequential-trace") return false;
-    return true;
+    if (autorouter.local && autorouter.groupMode === "subcircuit") return true;
+    if (!autorouter.local) return true;
+    return false;
   }
   _hasTracesToRoute() {
     const debug4 = Debug5("tscircuit:core:_hasTracesToRoute");
@@ -5372,7 +5718,11 @@ var Group = class extends NormalComponent {
           {
             method: "POST",
             body: JSON.stringify({
-              input_simple_route_json: this._getSimpleRouteJsonFromPcbTraces(),
+              input_simple_route_json: getSimpleRouteJsonFromCircuitJson({
+                db,
+                minTraceWidth: this.props.autorouter?.minTraceWidth ?? 0.15,
+                subcircuit_id: this.subcircuit_id
+              }).simpleRouteJson,
               subcircuit_id: this.subcircuit_id
             }),
             headers: { "Content-Type": "application/json" }
@@ -5450,12 +5800,73 @@ var Group = class extends NormalComponent {
       await new Promise((resolve) => setTimeout(resolve, 100));
     }
   }
+  /**
+   * Run local autorouting using the CapacityMeshAutorouter
+   */
+  async _runLocalCapacityMeshAutorouting() {
+    const { db } = this.root;
+    const debug4 = Debug5("tscircuit:core:_runLocalCapacityMeshAutorouting");
+    debug4(`[${this.getString()}] starting local capacity mesh autorouting`);
+    const { simpleRouteJson, connMap } = getSimpleRouteJsonFromCircuitJson({
+      db,
+      minTraceWidth: this.props.autorouter?.minTraceWidth ?? 0.15,
+      subcircuit_id: this.subcircuit_id
+    });
+    this.root?.emit("autorouting:start", {
+      subcircuit_id: this.subcircuit_id,
+      componentDisplayName: this.getString(),
+      simpleRouteJson
+    });
+    const autorouter = new CapacityMeshAutorouter(simpleRouteJson, {
+      // Optional configuration parameters
+      capacityDepth: this.props.autorouter?.capacityDepth,
+      targetMinCapacity: this.props.autorouter?.targetMinCapacity
+    });
+    const routingPromise = new Promise(
+      (resolve, reject) => {
+        autorouter.on("complete", (event) => {
+          debug4(`[${this.getString()}] local autorouting complete`);
+          resolve(event.traces);
+        });
+        autorouter.on("error", (event) => {
+          debug4(
+            `[${this.getString()}] local autorouting error: ${event.error.message}`
+          );
+          reject(event.error);
+        });
+      }
+    );
+    autorouter.start();
+    try {
+      const traces = await routingPromise;
+      this._asyncAutoroutingResult = {
+        output_pcb_traces: traces
+      };
+      this._markDirty("PcbTraceRender");
+    } catch (error) {
+      const { db: db2 } = this.root;
+      db2.pcb_autorouting_error.insert({
+        pcb_error_id: `local_${this.subcircuit_id}`,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    } finally {
+      autorouter.stop();
+    }
+  }
   _startAsyncAutorouting() {
     this._hasStartedAsyncAutorouting = true;
-    this._queueAsyncEffect(
-      "make-http-autorouting-request",
-      async () => this._runEffectMakeHttpAutoroutingRequest()
-    );
+    if (this._getAutorouterConfig().local) {
+      this._queueAsyncEffect(
+        "capacity-mesh-autorouting",
+        async () => this._runLocalCapacityMeshAutorouting()
+      );
+    } else {
+      this._queueAsyncEffect(
+        "make-http-autorouting-request",
+        async () => this._runEffectMakeHttpAutoroutingRequest()
+      );
+    }
   }
   doInitialPcbTraceRender() {
     const debug4 = Debug5("tscircuit:core:doInitialPcbTraceRender");
@@ -5477,6 +5888,7 @@ var Group = class extends NormalComponent {
   }
   updatePcbTraceRender() {
     const debug4 = Debug5("tscircuit:core:updatePcbTraceRender");
+    debug4(`[${this.getString()}] updating...`);
     if (!this.isSubcircuit) return;
     if (this._shouldRouteAsync() && this._hasTracesToRoute() && !this._hasStartedAsyncAutorouting) {
       if (this._areChildSubcircuitsRouted()) {
@@ -5491,10 +5903,16 @@ var Group = class extends NormalComponent {
     if (this._shouldUseTraceByTraceRouting()) return;
     const { db } = this.root;
     if (this._asyncAutoroutingResult.output_simple_route_json) {
+      debug4(
+        `[${this.getString()}] updating PCB traces from simple route json (${this._asyncAutoroutingResult.output_simple_route_json.traces?.length} traces)`
+      );
       this._updatePcbTraceRenderFromSimpleRouteJson();
       return;
     }
     if (this._asyncAutoroutingResult.output_pcb_traces) {
+      debug4(
+        `[${this.getString()}] updating PCB traces from ${this._asyncAutoroutingResult.output_pcb_traces.length} traces`
+      );
       this._updatePcbTraceRenderFromPcbTraces();
       return;
     }
@@ -5503,9 +5921,9 @@ var Group = class extends NormalComponent {
     const { db } = this.root;
     const { traces: routedTraces } = this._asyncAutoroutingResult.output_simple_route_json;
     if (!routedTraces) return;
-    const circuitTraces = this.selectAll("trace");
     for (const routedTrace of routedTraces) {
       const pcb_trace = db.pcb_trace.insert({
+        subcircuit_id: this.subcircuit_id,
         route: routedTrace.route
         // source_trace_id: circuitTrace.source_trace_id!,
       });
@@ -5519,6 +5937,22 @@ var Group = class extends NormalComponent {
       pcb_trace.subcircuit_id = this.subcircuit_id;
       db.pcb_trace.insert(pcb_trace);
     }
+    for (const pcb_trace of output_pcb_traces) {
+      for (const point of pcb_trace.route) {
+        if (point.route_type === "via") {
+          db.pcb_via.insert({
+            pcb_trace_id: pcb_trace.pcb_trace_id,
+            x: point.x,
+            y: point.y,
+            hole_diameter: 0.3,
+            outer_diameter: 0.6,
+            layers: [point.from_layer, point.to_layer],
+            from_layer: point.from_layer,
+            to_layer: point.to_layer
+          });
+        }
+      }
+    }
   }
   doInitialSchematicLayout() {
     if (!this.isSubcircuit) return;
@@ -5550,7 +5984,7 @@ var Group = class extends NormalComponent {
     const defaults = {
       serverUrl: "https://registry-api.tscircuit.com",
       serverMode: "job",
-      serverCacheEnabled: false
+      serverCacheEnabled: true
     };
     const autorouter = this._parsedProps.autorouter ?? this.getInheritedProperty("autorouter");
     if (typeof autorouter === "object") {
@@ -5562,13 +5996,27 @@ var Group = class extends NormalComponent {
     }
     if (autorouter === "auto-local")
       return {
-        local: true
+        local: true,
+        groupMode: "subcircuit"
       };
     if (autorouter === "sequential-trace")
       return {
         local: true,
         groupMode: "sequential-trace"
       };
+    if (autorouter === "subcircuit")
+      return {
+        local: true,
+        groupMode: "subcircuit"
+      };
+    if (autorouter === "auto-cloud")
+      return {
+        local: false,
+        groupMode: "subcircuit",
+        serverUrl: defaults.serverUrl,
+        serverMode: defaults.serverMode,
+        serverCacheEnabled: true
+      };
     return {
       local: true,
       groupMode: "sequential-trace"
@@ -6426,7 +6874,9 @@ var PinHeader = class extends NormalComponent {
         new Port({
           name: `pin${i}`,
           pinNumber: i,
-          aliases: []
+          aliases: [this._parsedProps.pinLabels?.[i - 1]].filter(
+            Boolean
+          )
         })
       );
     }
@@ -6747,7 +7197,7 @@ var Switch = class extends NormalComponent {
 };
 
 // lib/RootCircuit.ts
-import { su } from "@tscircuit/soup-util";
+import { su as su3 } from "@tscircuit/soup-util";
 import { isValidElement as isValidElement2 } from "react";
 import { identity as identity4 } from "transformation-matrix";
 var RootCircuit = class {
@@ -6768,7 +7218,7 @@ var RootCircuit = class {
   _hasRenderedAtleastOnce = false;
   constructor() {
     this.children = [];
-    this.db = su([]);
+    this.db = su3([]);
     this.root = this;
   }
   add(componentOrElm) {
@@ -7012,137 +7462,6 @@ var useResistor = createUseComponent(
   resistorPins2
 );
 
-// lib/utils/edit-events/apply-edit-events-to-manual-edits-file.ts
-import "zod";
-import { su as su2 } from "@tscircuit/soup-util";
-var applyEditEventsToManualEditsFile = ({
-  circuitJson,
-  editEvents,
-  manualEditsFile
-}) => {
-  const updatedManualEditsFile = {
-    ...manualEditsFile,
-    schematic_placements: [...manualEditsFile.schematic_placements ?? []]
-  };
-  for (const editEvent of editEvents) {
-    if (editEvent.edit_event_type === "edit_schematic_component_location") {
-      const { schematic_component_id, new_center } = editEvent;
-      const schematic_component2 = su2(circuitJson).schematic_component.get(
-        schematic_component_id
-      );
-      if (!schematic_component2) continue;
-      const source_component = su2(circuitJson).source_component.get(
-        schematic_component2.source_component_id
-      );
-      if (!source_component) continue;
-      const existingPlacementIndex = updatedManualEditsFile.schematic_placements?.findIndex(
-        (p) => p.selector === source_component.name
-      );
-      const newPlacement = {
-        selector: source_component.name,
-        center: new_center,
-        relative_to: "group_center"
-      };
-      if (existingPlacementIndex >= 0) {
-        updatedManualEditsFile.schematic_placements[existingPlacementIndex] = newPlacement;
-      } else {
-        updatedManualEditsFile.schematic_placements.push(newPlacement);
-      }
-    }
-  }
-  return updatedManualEditsFile;
-};
-
-// lib/utils/autorouting/getSimpleRouteJsonFromCircuitJson.ts
-import { getObstaclesFromSoup as getObstaclesFromSoup3 } from "@tscircuit/infgrid-ijump-astar";
-import { su as su3 } from "@tscircuit/soup-util";
-import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson2 } from "circuit-json-to-connectivity-map";
-var getSimpleRouteJsonFromCircuitJson = ({
-  circuitJson,
-  minTraceWidth = 0.1
-}) => {
-  const db = su3(circuitJson);
-  const connMap = getFullConnectivityMapFromCircuitJson2(circuitJson);
-  const obstacles = getObstaclesFromSoup3(
-    [
-      ...db.pcb_component.list(),
-      ...db.pcb_smtpad.list(),
-      ...db.pcb_plated_hole.list()
-    ],
-    connMap
-  );
-  const allPoints = obstacles.flatMap((o) => [
-    {
-      x: o.center.x - o.width / 2,
-      y: o.center.y - o.height / 2
-    },
-    {
-      x: o.center.x + o.width / 2,
-      y: o.center.y + o.height / 2
-    }
-  ]);
-  const bounds = {
-    minX: Math.min(...allPoints.map((p) => p.x)) - 1,
-    maxX: Math.max(...allPoints.map((p) => p.x)) + 1,
-    minY: Math.min(...allPoints.map((p) => p.y)) - 1,
-    maxY: Math.max(...allPoints.map((p) => p.y)) + 1
-  };
-  const connections = db.source_trace.list().map((trace) => {
-    const connectedPorts = trace.connected_source_port_ids.map((id) => {
-      const source_port = db.source_port.get(id);
-      const pcb_port = db.pcb_port.getWhere({ source_port_id: id });
-      return {
-        ...source_port,
-        ...pcb_port
-      };
-    });
-    if (connectedPorts.length < 2) return null;
-    return {
-      name: connMap.getNetConnectedToId(trace.source_trace_id) ?? trace.source_trace_id ?? "",
-      source_trace_id: trace.source_trace_id,
-      pointsToConnect: connectedPorts.map((port) => {
-        return {
-          x: port.x,
-          y: port.y,
-          layer: port.layers?.[0] ?? "top"
-        };
-      })
-    };
-  }).filter((c) => c !== null);
-  return {
-    bounds,
-    obstacles,
-    connections,
-    layerCount: 2,
-    minTraceWidth
-  };
-};
-
-// lib/utils/render-events/getPhaseTimingsFromRenderEvents.ts
-var getPhaseTimingsFromRenderEvents = (renderEvents) => {
-  const phaseTimings = {};
-  if (!renderEvents) return phaseTimings;
-  for (const renderPhase of orderedRenderPhases) {
-    phaseTimings[renderPhase] = 0;
-  }
-  const startEvents = /* @__PURE__ */ new Map();
-  for (const event of renderEvents) {
-    const [, , phase, eventType] = event.type.split(":");
-    if (eventType === "start") {
-      startEvents.set(`${phase}:${event.renderId}`, event);
-      continue;
-    }
-    if (eventType === "end") {
-      const startEvent = startEvents.get(`${phase}:${event.renderId}`);
-      if (startEvent) {
-        const duration = event.createdAt - startEvent.createdAt;
-        phaseTimings[phase] = (phaseTimings[phase] || 0) + duration;
-      }
-    }
-  }
-  return phaseTimings;
-};
-
 // lib/sel/sel.ts
 var sel = new Proxy(
   {},
@@ -7155,6 +7474,23 @@ var sel = new Proxy(
             if (prop1 === "net") {
               return `net.${prop2}`;
             }
+            if (prop1 === "subcircuit") {
+              return new Proxy(
+                {},
+                {
+                  get: (_3, prop3) => {
+                    return new Proxy(
+                      {},
+                      {
+                        get: (_4, prop4) => {
+                          return `subcircuit.${prop2} > .${prop3} > .${prop4}`;
+                        }
+                      }
+                    );
+                  }
+                }
+              );
+            }
             return `.${prop1} > .${prop2}`;
           }
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.330",
+  "version": "0.0.332",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -53,12 +53,13 @@
   },
   "dependencies": {
     "@lume/kiwi": "^0.4.3",
+    "@tscircuit/capacity-autorouter": "^0.0.12",
     "@tscircuit/infgrid-ijump-astar": "^0.0.33",
     "@tscircuit/math-utils": "^0.0.9",
     "@tscircuit/props": "^0.0.152",
     "@tscircuit/schematic-autolayout": "^0.0.6",
     "@tscircuit/soup-util": "^0.0.41",
-    "circuit-json": "^0.0.142",
+    "circuit-json": "^0.0.144",
     "circuit-json-to-connectivity-map": "^0.0.17",
     "format-si-unit": "^0.0.3",
     "nanoid": "^5.0.7",