@tscircuit/core 0.0.32 → 0.0.34

package/dist/index.d.ts

@@ -3348,6 +3348,7 @@ declare class PlatedHole extends PrimitiveComponent<typeof platedHoleProps> {
                 name: "top" | "bottom" | "inner1" | "inner2" | "inner3" | "inner4" | "inner5" | "inner6";
             }>>;
         }, "pcbRotation" | "layer">, {
+            name: zod.ZodOptional<zod.ZodString>;
             shape: zod.ZodLiteral<"circle">;
             holeDiameter: zod.ZodEffects<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>, number, string | number>;
             outerDiameter: zod.ZodEffects<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>, number, string | number>;
@@ -3358,6 +3359,7 @@ declare class PlatedHole extends PrimitiveComponent<typeof platedHoleProps> {
             outerDiameter: number;
             pcbX?: number | undefined;
             pcbY?: number | undefined;
+            name?: string | undefined;
             portHints?: (string | number)[] | undefined;
         }, {
             shape: "circle";
@@ -3365,6 +3367,7 @@ declare class PlatedHole extends PrimitiveComponent<typeof platedHoleProps> {
             outerDiameter: string | number;
             pcbX?: string | number | undefined;
             pcbY?: string | number | undefined;
+            name?: string | undefined;
             portHints?: (string | number)[] | undefined;
         }>, zod.ZodObject<zod.objectUtil.extendShape<Omit<{
             pcbX: zod.ZodOptional<zod.ZodEffects<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>, number, string | number>>;
@@ -3380,6 +3383,7 @@ declare class PlatedHole extends PrimitiveComponent<typeof platedHoleProps> {
                 name: "top" | "bottom" | "inner1" | "inner2" | "inner3" | "inner4" | "inner5" | "inner6";
             }>>;
         }, "pcbRotation" | "layer">, {
+            name: zod.ZodOptional<zod.ZodString>;
             shape: zod.ZodLiteral<"oval">;
             outerWidth: zod.ZodEffects<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>, number, string | number>;
             outerHeight: zod.ZodEffects<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>, number, string | number>;
@@ -3394,6 +3398,7 @@ declare class PlatedHole extends PrimitiveComponent<typeof platedHoleProps> {
             innerHeight: number;
             pcbX?: number | undefined;
             pcbY?: number | undefined;
+            name?: string | undefined;
             portHints?: (string | number)[] | undefined;
         }, {
             shape: "oval";
@@ -3403,6 +3408,7 @@ declare class PlatedHole extends PrimitiveComponent<typeof platedHoleProps> {
             innerHeight: string | number;
             pcbX?: string | number | undefined;
             pcbY?: string | number | undefined;
+            name?: string | undefined;
             portHints?: (string | number)[] | undefined;
         }>]>;
     };
@@ -3410,84 +3416,98 @@ declare class PlatedHole extends PrimitiveComponent<typeof platedHoleProps> {
         width: number;
         height: number;
     };
+    _getCircuitJsonBounds(): {
+        center: {
+            x: number;
+            y: number;
+        };
+        bounds: {
+            left: number;
+            top: number;
+            right: number;
+            bottom: number;
+        };
+        width: number;
+        height: number;
+    };
+    _setPositionFromLayout(newCenter: {
+        x: number;
+        y: number;
+    }): void;
     doInitialPortMatching(): void;
     doInitialPcbPrimitiveRender(): void;
 }
 
+declare const edgeSpecifiers: readonly ["leftedge", "rightedge", "topedge", "bottomedge", "center"];
+type EdgeSpecifier = (typeof edgeSpecifiers)[number];
 declare class Constraint extends PrimitiveComponent<typeof constraintProps> {
     get config(): {
         zodProps: z.ZodUnion<[z.ZodObject<{
             pcb: z.ZodOptional<z.ZodLiteral<true>>;
-            type: z.ZodOptional<z.ZodLiteral<"xdist">>;
-            xdist: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>;
+            xDist: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>;
             left: z.ZodString;
             right: z.ZodString;
             edgeToEdge: z.ZodOptional<z.ZodLiteral<true>>;
             centerToCenter: z.ZodOptional<z.ZodLiteral<true>>;
-            fromLeftEdge: z.ZodOptional<z.ZodLiteral<true>>;
-            fromLeftCenter: z.ZodOptional<z.ZodLiteral<true>>;
-            toRightEdge: z.ZodOptional<z.ZodLiteral<true>>;
-            toRightCenter: z.ZodOptional<z.ZodLiteral<true>>;
         }, "strip", z.ZodTypeAny, {
             left: string;
             right: string;
-            xdist: number;
-            type?: "xdist" | undefined;
+            xDist: number;
             pcb?: true | undefined;
             edgeToEdge?: true | undefined;
             centerToCenter?: true | undefined;
-            fromLeftEdge?: true | undefined;
-            fromLeftCenter?: true | undefined;
-            toRightEdge?: true | undefined;
-            toRightCenter?: true | undefined;
         }, {
             left: string;
             right: string;
-            xdist: string | number;
-            type?: "xdist" | undefined;
+            xDist: string | number;
             pcb?: true | undefined;
             edgeToEdge?: true | undefined;
             centerToCenter?: true | undefined;
-            fromLeftEdge?: true | undefined;
-            fromLeftCenter?: true | undefined;
-            toRightEdge?: true | undefined;
-            toRightCenter?: true | undefined;
         }>, z.ZodObject<{
             pcb: z.ZodOptional<z.ZodLiteral<true>>;
-            type: z.ZodOptional<z.ZodLiteral<"ydist">>;
-            ydist: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>;
+            yDist: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>;
             top: z.ZodString;
             bottom: z.ZodString;
             edgeToEdge: z.ZodOptional<z.ZodLiteral<true>>;
             centerToCenter: z.ZodOptional<z.ZodLiteral<true>>;
-            fromTopEdge: z.ZodOptional<z.ZodLiteral<true>>;
-            fromTopCenter: z.ZodOptional<z.ZodLiteral<true>>;
-            toBottomEdge: z.ZodOptional<z.ZodLiteral<true>>;
-            toBottomCenter: z.ZodOptional<z.ZodLiteral<true>>;
         }, "strip", z.ZodTypeAny, {
             top: string;
             bottom: string;
-            ydist: number;
-            type?: "ydist" | undefined;
+            yDist: number;
             pcb?: true | undefined;
             edgeToEdge?: true | undefined;
             centerToCenter?: true | undefined;
-            fromTopEdge?: true | undefined;
-            fromTopCenter?: true | undefined;
-            toBottomEdge?: true | undefined;
-            toBottomCenter?: true | undefined;
         }, {
             top: string;
             bottom: string;
-            ydist: string | number;
-            type?: "ydist" | undefined;
+            yDist: string | number;
             pcb?: true | undefined;
             edgeToEdge?: true | undefined;
             centerToCenter?: true | undefined;
-            fromTopEdge?: true | undefined;
-            fromTopCenter?: true | undefined;
-            toBottomEdge?: true | undefined;
-            toBottomCenter?: true | undefined;
+        }>, z.ZodObject<{
+            pcb: z.ZodOptional<z.ZodLiteral<true>>;
+            sameY: z.ZodOptional<z.ZodLiteral<true>>;
+            for: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            for: string[];
+            pcb?: true | undefined;
+            sameY?: true | undefined;
+        }, {
+            for: string[];
+            pcb?: true | undefined;
+            sameY?: true | undefined;
+        }>, z.ZodObject<{
+            pcb: z.ZodOptional<z.ZodLiteral<true>>;
+            sameX: z.ZodOptional<z.ZodLiteral<true>>;
+            for: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            for: string[];
+            pcb?: true | undefined;
+            sameX?: true | undefined;
+        }, {
+            for: string[];
+            pcb?: true | undefined;
+            sameX?: true | undefined;
         }>]>;
     };
     constructor(props: z.input<typeof constraintProps>);
@@ -3495,6 +3515,8 @@ declare class Constraint extends PrimitiveComponent<typeof constraintProps> {
         componentsWithSelectors: Array<{
             component: PrimitiveComponent<any>;
             selector: string;
+            componentSelector: string;
+            edge: EdgeSpecifier | undefined;
         }>;
     };
 }
@@ -3503,7 +3525,7 @@ declare class Hole extends PrimitiveComponent<typeof holeProps> {
     pcb_hole_id: string | null;
     isPcbPrimitive: boolean;
     get config(): {
-        zodProps: zod.ZodObject<zod.objectUtil.extendShape<Omit<{
+        zodProps: zod.ZodEffects<zod.ZodObject<zod.objectUtil.extendShape<Omit<{
             pcbX: zod.ZodOptional<zod.ZodEffects<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>, number, string | number>>;
             pcbY: zod.ZodOptional<zod.ZodEffects<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>, number, string | number>>;
             pcbRotation: zod.ZodOptional<zod.ZodEffects<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>, number, string | number>>;
@@ -3517,19 +3539,41 @@ declare class Hole extends PrimitiveComponent<typeof holeProps> {
                 name: "top" | "bottom" | "inner1" | "inner2" | "inner3" | "inner4" | "inner5" | "inner6";
             }>>;
         }, "pcbRotation">, {
-            holeDiameter: zod.ZodEffects<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>, number, string | number>;
+            name: zod.ZodOptional<zod.ZodString>;
+            diameter: zod.ZodOptional<zod.ZodEffects<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>, number, string | number>>;
+            radius: zod.ZodOptional<zod.ZodEffects<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>, number, string | number>>;
         }>, "strip", zod.ZodTypeAny, {
-            holeDiameter: number;
             pcbX?: number | undefined;
             pcbY?: number | undefined;
             layer?: "top" | "bottom" | "inner1" | "inner2" | "inner3" | "inner4" | "inner5" | "inner6" | undefined;
+            name?: string | undefined;
+            radius?: number | undefined;
+            diameter?: number | undefined;
+        }, {
+            pcbX?: string | number | undefined;
+            pcbY?: string | number | undefined;
+            layer?: "top" | "bottom" | "inner1" | "inner2" | "inner3" | "inner4" | "inner5" | "inner6" | {
+                name: "top" | "bottom" | "inner1" | "inner2" | "inner3" | "inner4" | "inner5" | "inner6";
+            } | undefined;
+            name?: string | undefined;
+            radius?: string | number | undefined;
+            diameter?: string | number | undefined;
+        }>, {
+            diameter: number;
+            radius: number;
+            pcbX?: number | undefined;
+            pcbY?: number | undefined;
+            layer?: "top" | "bottom" | "inner1" | "inner2" | "inner3" | "inner4" | "inner5" | "inner6" | undefined;
+            name?: string | undefined;
         }, {
-            holeDiameter: string | number;
             pcbX?: string | number | undefined;
             pcbY?: string | number | undefined;
             layer?: "top" | "bottom" | "inner1" | "inner2" | "inner3" | "inner4" | "inner5" | "inner6" | {
                 name: "top" | "bottom" | "inner1" | "inner2" | "inner3" | "inner4" | "inner5" | "inner6";
             } | undefined;
+            name?: string | undefined;
+            radius?: string | number | undefined;
+            diameter?: string | number | undefined;
         }>;
     };
     getPcbSize(): {
@@ -3537,6 +3581,24 @@ declare class Hole extends PrimitiveComponent<typeof holeProps> {
         height: number;
     };
     doInitialPcbPrimitiveRender(): void;
+    _getCircuitJsonBounds(): {
+        center: {
+            x: number;
+            y: number;
+        };
+        bounds: {
+            left: number;
+            top: number;
+            right: number;
+            bottom: number;
+        };
+        width: number;
+        height: number;
+    };
+    _setPositionFromLayout(newCenter: {
+        x: number;
+        y: number;
+    }): void;
 }
 
 declare global {

package/dist/index.js

@@ -522,11 +522,18 @@ var Footprint = class extends PrimitiveComponent {
     if (constraints.length === 0) return;
     const involvedComponents = constraints.flatMap(
       (constraint) => constraint._getAllReferencedComponents().componentsWithSelectors
-    ).map(({ component, selector }) => ({
+    ).map(({ component, selector, componentSelector, edge }) => ({
       component,
       selector,
+      componentSelector,
+      edge,
       bounds: component._getCircuitJsonBounds()
     }));
+    if (involvedComponents.some((c) => c.edge)) {
+      throw new Error(
+        "edge constraints not implemented yet for footprint layout, contributions welcome!"
+      );
+    }
     function getComponentDetails(selector) {
       return involvedComponents.find(({ selector: s }) => s === selector);
     }
@@ -535,21 +542,20 @@ var Footprint = class extends PrimitiveComponent {
     function getKVar(name) {
       if (!(name in kVars)) {
         kVars[name] = new kiwi.Variable(name);
+        solver.addEditVariable(kVars[name], kiwi.Strength.weak);
       }
       return kVars[name];
     }
-    for (const { selector, bounds } of involvedComponents) {
+    for (const { selector, bounds: bounds2 } of involvedComponents) {
       const kvx = getKVar(`${selector}_x`);
       const kvy = getKVar(`${selector}_y`);
-      solver.addEditVariable(kvx, kiwi.Strength.weak);
-      solver.addEditVariable(kvy, kiwi.Strength.weak);
-      solver.suggestValue(kvx, bounds.center.x);
-      solver.suggestValue(kvy, bounds.center.y);
+      solver.suggestValue(kvx, bounds2.center.x);
+      solver.suggestValue(kvy, bounds2.center.y);
     }
     for (const constraint of constraints) {
       const props = constraint._parsedProps;
-      if ("xdist" in props) {
-        const { xdist, left, right, edgeToEdge, centerToCenter } = props;
+      if ("xDist" in props) {
+        const { xDist, left, right, edgeToEdge, centerToCenter } = props;
         const leftVar = getKVar(`${left}_x`);
         const rightVar = getKVar(`${right}_x`);
         const leftBounds = getComponentDetails(left)?.bounds;
@@ -560,14 +566,14 @@ var Footprint = class extends PrimitiveComponent {
             new kiwi.Constraint(
               expr,
               kiwi.Operator.Eq,
-              props.xdist,
+              props.xDist,
               kiwi.Strength.required
             )
           );
         } else if (edgeToEdge) {
           const expr = new kiwi.Expression(
             rightVar,
-            rightBounds.width / 2,
+            -rightBounds.width / 2,
             [-1, leftVar],
             -leftBounds.width / 2
           );
@@ -575,55 +581,113 @@ var Footprint = class extends PrimitiveComponent {
             new kiwi.Constraint(
               expr,
               kiwi.Operator.Eq,
-              props.xdist,
+              props.xDist,
               kiwi.Strength.required
             )
           );
         }
-      }
-      solver.updateVariables();
-      if (debug.enabled) {
-        console.log("Solution to layout constraints:");
-        console.table(
-          Object.entries(kVars).map(([key, kvar]) => ({
-            var: key,
-            val: kvar.value()
-          }))
+      } else if ("yDist" in props) {
+        const { yDist, top, bottom, edgeToEdge, centerToCenter } = props;
+        const topVar = getKVar(`${top}_y`);
+        const bottomVar = getKVar(`${bottom}_y`);
+        const topBounds = getComponentDetails(top)?.bounds;
+        const bottomBounds = getComponentDetails(bottom)?.bounds;
+        if (centerToCenter) {
+          const expr = new kiwi.Expression(topVar, [-1, bottomVar]);
+          solver.addConstraint(
+            new kiwi.Constraint(
+              expr,
+              kiwi.Operator.Eq,
+              props.yDist,
+              kiwi.Strength.required
+            )
+          );
+        } else if (edgeToEdge) {
+          const expr = new kiwi.Expression(
+            topVar,
+            topBounds.height / 2,
+            [-1, bottomVar],
+            -bottomBounds.height / 2
+          );
+          solver.addConstraint(
+            new kiwi.Constraint(
+              expr,
+              kiwi.Operator.Eq,
+              props.yDist,
+              kiwi.Strength.required
+            )
+          );
+        }
+      } else if ("sameY" in props) {
+        const { for: selectors } = props;
+        if (selectors.length < 2) continue;
+        const vars = selectors.map((selector) => getKVar(`${selector}_y`));
+        const expr = new kiwi.Expression(...vars.slice(1));
+        solver.addConstraint(
+          new kiwi.Constraint(
+            expr,
+            kiwi.Operator.Eq,
+            vars[0],
+            kiwi.Strength.required
+          )
+        );
+      } else if ("sameX" in props) {
+        const { for: selectors } = props;
+        if (selectors.length < 2) continue;
+        const vars = selectors.map((selector) => getKVar(`${selector}_x`));
+        const expr = new kiwi.Expression(...vars.slice(1));
+        solver.addConstraint(
+          new kiwi.Constraint(
+            expr,
+            kiwi.Operator.Eq,
+            vars[0],
+            kiwi.Strength.required
+          )
         );
       }
-      const bounds = {
-        left: Infinity,
-        right: -Infinity,
-        top: -Infinity,
-        bottom: Infinity
-      };
-      for (const {
-        selector,
-        bounds: { width, height }
-      } of involvedComponents) {
-        const kvx = getKVar(`${selector}_x`);
-        const kvy = getKVar(`${selector}_y`);
-        const newLeft = kvx.value() - width / 2;
-        const newRight = kvx.value() + width / 2;
-        const newTop = kvy.value() + height / 2;
-        const newBottom = kvy.value() - height / 2;
-        bounds.left = Math.min(bounds.left, newLeft);
-        bounds.right = Math.max(bounds.right, newRight);
-        bounds.top = Math.max(bounds.top, newTop);
-        bounds.bottom = Math.min(bounds.bottom, newBottom);
-      }
-      const globalOffset = {
-        x: -(bounds.right + bounds.left) / 2,
-        y: -(bounds.top + bounds.bottom) / 2
-      };
-      for (const { component, selector } of involvedComponents) {
-        const kvx = getKVar(`${selector}_x`);
-        const kvy = getKVar(`${selector}_y`);
-        component._setPositionFromLayout({
-          x: kvx.value() + globalOffset.x,
-          y: kvy.value() + globalOffset.y
-        });
-      }
+    }
+    solver.updateVariables();
+    if (debug.enabled) {
+      console.log("Solution to layout constraints:");
+      console.table(
+        Object.entries(kVars).map(([key, kvar]) => ({
+          var: key,
+          val: kvar.value()
+        }))
+      );
+    }
+    const bounds = {
+      left: Infinity,
+      right: -Infinity,
+      top: -Infinity,
+      bottom: Infinity
+    };
+    for (const {
+      selector,
+      bounds: { width, height }
+    } of involvedComponents) {
+      const kvx = getKVar(`${selector}_x`);
+      const kvy = getKVar(`${selector}_y`);
+      const newLeft = kvx.value() - width / 2;
+      const newRight = kvx.value() + width / 2;
+      const newTop = kvy.value() + height / 2;
+      const newBottom = kvy.value() - height / 2;
+      bounds.left = Math.min(bounds.left, newLeft);
+      bounds.right = Math.max(bounds.right, newRight);
+      bounds.top = Math.max(bounds.top, newTop);
+      bounds.bottom = Math.min(bounds.bottom, newBottom);
+    }
+    const globalOffset = {
+      x: -(bounds.right + bounds.left) / 2,
+      y: -(bounds.top + bounds.bottom) / 2
+    };
+    for (const { component, selector } of involvedComponents) {
+      const kvx = getKVar(`${selector}_x`);
+      const kvy = getKVar(`${selector}_y`);
+      component._setPositionFromLayout({
+        x: kvx.value() + globalOffset.x,
+        y: kvy.value() + globalOffset.y
+      });
     }
   }
 };
@@ -1164,6 +1228,29 @@ var PlatedHole = class extends PrimitiveComponent {
       `getPcbSize for shape "${props.shape}" not implemented for ${this.componentName}`
     );
   }
+  _getCircuitJsonBounds() {
+    const { db } = this.root;
+    const platedHole = db.pcb_plated_hole.get(this.pcb_plated_hole_id);
+    const size = this.getPcbSize();
+    return {
+      center: { x: platedHole.x, y: platedHole.y },
+      bounds: {
+        left: platedHole.x - size.width / 2,
+        top: platedHole.y - size.height / 2,
+        right: platedHole.x + size.width / 2,
+        bottom: platedHole.y + size.height / 2
+      },
+      width: size.width,
+      height: size.height
+    };
+  }
+  _setPositionFromLayout(newCenter) {
+    const { db } = this.root;
+    db.pcb_plated_hole.update(this.pcb_plated_hole_id, {
+      x: newCenter.x,
+      y: newCenter.y
+    });
+  }
   doInitialPortMatching() {
     const parentPorts = (this.parent?.children ?? []).filter(
       (c) => c.componentName === "Port"
@@ -1182,22 +1269,21 @@ var PlatedHole = class extends PrimitiveComponent {
   doInitialPcbPrimitiveRender() {
     const { db } = this.root;
     const { _parsedProps: props } = this;
-    if (!props.portHints) return;
     const position = this._getGlobalPcbPositionBeforeLayout();
     if (props.shape === "circle") {
-      const plated_hole_input = {
+      const pcb_plated_hole = db.pcb_plated_hole.insert({
         pcb_component_id: this.parent?.pcb_component_id,
         pcb_port_id: this.matchedPort?.pcb_port_id,
-        layers: ["top", "bottom"],
+        // @ts-ignore - some issue with @tscircuit/soup union type
         outer_diameter: props.outerDiameter,
         hole_diameter: props.holeDiameter,
         shape: "circle",
         port_hints: this.getNameAndAliases(),
         x: position.x,
         y: position.y,
-        type: "pcb_plated_hole"
-      };
-      const pcb_plated_hole = db.pcb_plated_hole.insert(plated_hole_input);
+        layers: ["top", "bottom"]
+      });
+      this.pcb_plated_hole_id = pcb_plated_hole.pcb_plated_hole_id;
     }
   }
 };
@@ -2888,6 +2974,13 @@ var Jumper = class extends NormalComponent {
 // lib/components/primitive-components/Constraint.ts
 import { constraintProps } from "@tscircuit/props";
 import "zod";
+var edgeSpecifiers = [
+  "leftedge",
+  "rightedge",
+  "topedge",
+  "bottomedge",
+  "center"
+];
 var Constraint2 = class extends PrimitiveComponent {
   get config() {
     return {
@@ -2899,23 +2992,38 @@ var Constraint2 = class extends PrimitiveComponent {
     if ("xdist" in props || "ydist" in props) {
       if (!("edgeToEdge" in props) && !("centerToCenter" in props)) {
         throw new Error(
-          "edgeToEdge, centerToCenter (or from*/to* props) must be set for xdist or ydist for <constraint />"
+          `edgeToEdge, centerToCenter must be set for xDist or yDist for ${this}`
         );
       }
     }
+    if ("for" in props && props.for.length < 2) {
+      throw new Error(`"for" must have at least two selectors for ${this}`);
+    }
   }
   _getAllReferencedComponents() {
     const componentsWithSelectors = [];
+    const subcircuit = this.getSubcircuit();
+    function addComponentFromSelector(selector) {
+      const component = subcircuit.selectOne(selector);
+      if (component) {
+        const maybeEdge = selector.split(" ").pop();
+        const edge = edgeSpecifiers.includes(maybeEdge) ? maybeEdge : void 0;
+        componentsWithSelectors.push({
+          selector,
+          component,
+          componentSelector: edge ? selector.replace(` ${edge}`, "") : selector,
+          edge
+        });
+      }
+    }
     for (const key of ["left", "right", "top", "bottom"]) {
       if (key in this._parsedProps) {
-        const selector = this._parsedProps[key];
-        const component = this.getSubcircuit().selectOne(selector);
-        if (component) {
-          componentsWithSelectors.push({
-            selector,
-            component
-          });
-        }
+        addComponentFromSelector(this._parsedProps[key]);
+      }
+    }
+    if ("for" in this._parsedProps) {
+      for (const selector of this._parsedProps.for) {
+        addComponentFromSelector(selector);
       }
     }
     return { componentsWithSelectors };
@@ -2934,20 +3042,43 @@ var Hole = class extends PrimitiveComponent {
   }
   getPcbSize() {
     const { _parsedProps: props } = this;
-    return { width: props.holeDiameter, height: props.holeDiameter };
+    return { width: props.diameter, height: props.diameter };
   }
   doInitialPcbPrimitiveRender() {
     const { db } = this.root;
     const { _parsedProps: props } = this;
     const position = this._getGlobalPcbPositionBeforeLayout();
-    const pcb_hole = {
-      type: "pcb_hole",
+    const inserted_hole = db.pcb_hole.insert({
       hole_shape: "round",
-      hole_diameter: props.holeDiameter,
+      // @ts-ignore
+      hole_diameter: props.diameter,
       x: position.x,
       y: position.y
+    });
+    this.pcb_hole_id = inserted_hole.pcb_hole_id;
+  }
+  _getCircuitJsonBounds() {
+    const { db } = this.root;
+    const hole = db.pcb_hole.get(this.pcb_hole_id);
+    const size = this.getPcbSize();
+    return {
+      center: { x: hole.x, y: hole.y },
+      bounds: {
+        left: hole.x - size.width / 2,
+        top: hole.y - size.height / 2,
+        right: hole.x + size.width / 2,
+        bottom: hole.y + size.height / 2
+      },
+      width: size.width,
+      height: size.height
     };
-    const inserted_hole = db.pcb_hole.insert(pcb_hole);
+  }
+  _setPositionFromLayout(newCenter) {
+    const { db } = this.root;
+    db.pcb_hole.update(this.pcb_hole_id, {
+      x: newCenter.x,
+      y: newCenter.y
+    });
   }
 };
 

package/lib/components/primitive-components/Constraint.ts

@@ -2,6 +2,16 @@ import { constraintProps } from "@tscircuit/props"
 import { z } from "zod"
 import { PrimitiveComponent } from "../base-components/PrimitiveComponent"
 
+const edgeSpecifiers = [
+  "leftedge",
+  "rightedge",
+  "topedge",
+  "bottomedge",
+  "center",
+] as const
+
+export type EdgeSpecifier = (typeof edgeSpecifiers)[number]
+
 export class Constraint extends PrimitiveComponent<typeof constraintProps> {
   get config() {
     return {
@@ -13,34 +23,60 @@ export class Constraint extends PrimitiveComponent<typeof constraintProps> {
     super(props)
     if ("xdist" in props || "ydist" in props) {
       if (!("edgeToEdge" in props) && !("centerToCenter" in props)) {
+        // TODO don't throw an error if the selectors specify an edge
         throw new Error(
-          "edgeToEdge, centerToCenter (or from*/to* props) must be set for xdist or ydist for <constraint />",
+          `edgeToEdge, centerToCenter must be set for xDist or yDist for ${this}`,
         )
       }
     }
+    if ("for" in props && props.for.length < 2) {
+      throw new Error(`"for" must have at least two selectors for ${this}`)
+    }
   }
 
   _getAllReferencedComponents(): {
     componentsWithSelectors: Array<{
       component: PrimitiveComponent<any>
       selector: string
+      componentSelector: string
+      edge: EdgeSpecifier | undefined
     }>
   } {
     const componentsWithSelectors: Array<{
       component: PrimitiveComponent<any>
       selector: string
+      componentSelector: string
+      edge: EdgeSpecifier | undefined
     }> = []
 
+    const subcircuit = this.getSubcircuit()
+
+    function addComponentFromSelector(selector: string) {
+      // TODO this selector has to be modified in case it contains a leftedge,
+      // center/topedge/rightedge indicator
+      const component = subcircuit.selectOne(selector)
+      if (component) {
+        const maybeEdge = selector.split(" ").pop() as EdgeSpecifier
+        const edge = edgeSpecifiers.includes(maybeEdge) ? maybeEdge : undefined
+
+        componentsWithSelectors.push({
+          selector,
+          component,
+          componentSelector: edge ? selector.replace(` ${edge}`, "") : selector,
+          edge,
+        })
+      }
+    }
+
     for (const key of ["left", "right", "top", "bottom"]) {
       if (key in this._parsedProps) {
-        const selector = (this._parsedProps as any)[key] as string
-        const component = this.getSubcircuit().selectOne(selector)
-        if (component) {
-          componentsWithSelectors.push({
-            selector,
-            component,
-          })
-        }
+        addComponentFromSelector((this._parsedProps as any)[key] as string)
+      }
+    }
+
+    if ("for" in this._parsedProps) {
+      for (const selector of this._parsedProps.for) {
+        addComponentFromSelector(selector)
       }
     }
 

package/lib/components/primitive-components/Footprint.ts

@@ -23,12 +23,20 @@ export class Footprint extends PrimitiveComponent<typeof footprintProps> {
         (constraint) =>
           constraint._getAllReferencedComponents().componentsWithSelectors,
       )
-      .map(({ component, selector }) => ({
+      .map(({ component, selector, componentSelector, edge }) => ({
         component,
         selector,
+        componentSelector,
+        edge,
         bounds: component._getCircuitJsonBounds(),
       }))
 
+    if (involvedComponents.some((c) => c.edge)) {
+      throw new Error(
+        "edge constraints not implemented yet for footprint layout, contributions welcome!",
+      )
+    }
+
     function getComponentDetails(selector: string) {
       return involvedComponents.find(({ selector: s }) => s === selector)
     }
@@ -39,6 +47,7 @@ export class Footprint extends PrimitiveComponent<typeof footprintProps> {
     function getKVar(name: string) {
       if (!(name in kVars)) {
         kVars[name] = new kiwi.Variable(name)
+        solver.addEditVariable(kVars[name], kiwi.Strength.weak)
       }
       return kVars[name]
     }
@@ -47,8 +56,6 @@ export class Footprint extends PrimitiveComponent<typeof footprintProps> {
     for (const { selector, bounds } of involvedComponents) {
       const kvx = getKVar(`${selector}_x`)
       const kvy = getKVar(`${selector}_y`)
-      solver.addEditVariable(kvx, kiwi.Strength.weak)
-      solver.addEditVariable(kvy, kiwi.Strength.weak)
       solver.suggestValue(kvx, bounds.center.x)
       solver.suggestValue(kvy, bounds.center.y)
     }
@@ -57,8 +64,8 @@ export class Footprint extends PrimitiveComponent<typeof footprintProps> {
     for (const constraint of constraints) {
       const props = constraint._parsedProps
 
-      if ("xdist" in props) {
-        const { xdist, left, right, edgeToEdge, centerToCenter } = props
+      if ("xDist" in props) {
+        const { xDist, left, right, edgeToEdge, centerToCenter } = props
         const leftVar = getKVar(`${left}_x`)
         const rightVar = getKVar(`${right}_x`)
         const leftBounds = getComponentDetails(left)?.bounds!
@@ -71,16 +78,16 @@ export class Footprint extends PrimitiveComponent<typeof footprintProps> {
             new kiwi.Constraint(
               expr,
               kiwi.Operator.Eq,
-              props.xdist,
+              props.xDist,
               kiwi.Strength.required,
             ),
           )
         } else if (edgeToEdge) {
           // rightEdge - leftEdge = xdist
-          // right + rightBounds.width/2 - left - leftBounds.width/2 = xdist
+          // right - rightBounds.width/2 - left - leftBounds.width/2 = xdist
           const expr = new kiwi.Expression(
             rightVar,
-            rightBounds.width / 2,
+            -rightBounds.width / 2,
             [-1, leftVar],
             -leftBounds.width / 2,
           )
@@ -88,74 +95,139 @@ export class Footprint extends PrimitiveComponent<typeof footprintProps> {
             new kiwi.Constraint(
               expr,
               kiwi.Operator.Eq,
-              props.xdist,
+              props.xDist,
               kiwi.Strength.required,
             ),
           )
         }
-      }
+      } else if ("yDist" in props) {
+        const { yDist, top, bottom, edgeToEdge, centerToCenter } = props
+        const topVar = getKVar(`${top}_y`)
+        const bottomVar = getKVar(`${bottom}_y`)
+        const topBounds = getComponentDetails(top)?.bounds!
+        const bottomBounds = getComponentDetails(bottom)?.bounds!
+
+        // Top - Bottom = ydist
 
-      // 3. Solve the system of equations
-      solver.updateVariables()
-      if (debug.enabled) {
-        console.log("Solution to layout constraints:")
-        console.table(
-          Object.entries(kVars).map(([key, kvar]) => ({
-            var: key,
-            val: kvar.value(),
-          })),
+        if (centerToCenter) {
+          // top - bottom = ydist
+          const expr = new kiwi.Expression(topVar, [-1, bottomVar])
+          solver.addConstraint(
+            new kiwi.Constraint(
+              expr,
+              kiwi.Operator.Eq,
+              props.yDist,
+              kiwi.Strength.required,
+            ),
+          )
+        } else if (edgeToEdge) {
+          // topElmBottomEdge - bottomElmTopEdge = ydist
+          // topElmCenterY - topElmHeight/2 - bottomElmCenterY - bottomElmHeight/2 = ydist
+          const expr = new kiwi.Expression(
+            topVar,
+            topBounds.height / 2,
+            [-1, bottomVar],
+            -bottomBounds.height / 2,
+          )
+          solver.addConstraint(
+            new kiwi.Constraint(
+              expr,
+              kiwi.Operator.Eq,
+              props.yDist,
+              kiwi.Strength.required,
+            ),
+          )
+        }
+      } else if ("sameY" in props) {
+        const { for: selectors } = props
+        if (selectors.length < 2) continue
+        const vars = selectors.map((selector) => getKVar(`${selector}_y`))
+        const expr = new kiwi.Expression(...vars.slice(1))
+
+        solver.addConstraint(
+          new kiwi.Constraint(
+            expr,
+            kiwi.Operator.Eq,
+            vars[0],
+            kiwi.Strength.required,
+          ),
+        )
+      } else if ("sameX" in props) {
+        const { for: selectors } = props
+        if (selectors.length < 2) continue
+        const vars = selectors.map((selector) => getKVar(`${selector}_x`))
+        const expr = new kiwi.Expression(...vars.slice(1))
+        solver.addConstraint(
+          new kiwi.Constraint(
+            expr,
+            kiwi.Operator.Eq,
+            vars[0],
+            kiwi.Strength.required,
+          ),
         )
       }
+    }
 
-      // 3.1 Compute the global offset. There are different ways to do this:
-      // - If any component has a fixed position, then that can be used as the
-      //   origin to determine the offset of all other components
-      // - If no component has a fixed position, then we recenter everything
-      //   using the new bounds of all the involved components
-
-      // TODO determine if there's a fixed component
-
-      // Determine the new bounds all the involved components and compute the
-      // bounds of this footprint
-      const bounds = {
-        left: Infinity,
-        right: -Infinity,
-        top: -Infinity,
-        bottom: Infinity,
-      }
-      for (const {
-        selector,
-        bounds: { width, height },
-      } of involvedComponents) {
-        const kvx = getKVar(`${selector}_x`)
-        const kvy = getKVar(`${selector}_y`)
-
-        const newLeft = kvx.value() - width / 2
-        const newRight = kvx.value() + width / 2
-        const newTop = kvy.value() + height / 2
-        const newBottom = kvy.value() - height / 2
-
-        bounds.left = Math.min(bounds.left, newLeft)
-        bounds.right = Math.max(bounds.right, newRight)
-        bounds.top = Math.max(bounds.top, newTop)
-        bounds.bottom = Math.min(bounds.bottom, newBottom)
-      }
+    // 3. Solve the system of equations
+    solver.updateVariables()
+    if (debug.enabled) {
+      console.log("Solution to layout constraints:")
+      console.table(
+        Object.entries(kVars).map(([key, kvar]) => ({
+          var: key,
+          val: kvar.value(),
+        })),
+      )
+    }
 
-      // Compute the global offset, we can use this to recenter each component
-      const globalOffset = {
-        x: -(bounds.right + bounds.left) / 2,
-        y: -(bounds.top + bounds.bottom) / 2,
-      }
+    // 3.1 Compute the global offset. There are different ways to do this:
+    // - If any component has a fixed position, then that can be used as the
+    //   origin to determine the offset of all other components
+    // - If no component has a fixed position, then we recenter everything
+    //   using the new bounds of all the involved components
+
+    // TODO determine if there's a fixed component
+
+    // Determine the new bounds all the involved components and compute the
+    // bounds of this footprint
+    const bounds = {
+      left: Infinity,
+      right: -Infinity,
+      top: -Infinity,
+      bottom: Infinity,
+    }
+    for (const {
+      selector,
+      bounds: { width, height },
+    } of involvedComponents) {
+      const kvx = getKVar(`${selector}_x`)
+      const kvy = getKVar(`${selector}_y`)
 
-      // 4. Update the component positions
-      for (const { component, selector } of involvedComponents) {
-        const kvx = getKVar(`${selector}_x`)
-        const kvy = getKVar(`${selector}_y`)
-        component._setPositionFromLayout({
-          x: kvx.value() + globalOffset.x,
-          y: kvy.value() + globalOffset.y,
-        })
-      }
+      const newLeft = kvx.value() - width / 2
+      const newRight = kvx.value() + width / 2
+      const newTop = kvy.value() + height / 2
+      const newBottom = kvy.value() - height / 2
+
+      bounds.left = Math.min(bounds.left, newLeft)
+      bounds.right = Math.max(bounds.right, newRight)
+      bounds.top = Math.max(bounds.top, newTop)
+      bounds.bottom = Math.min(bounds.bottom, newBottom)
+    }
+
+    // Compute the global offset, we can use this to recenter each component
+    const globalOffset = {
+      x: -(bounds.right + bounds.left) / 2,
+      y: -(bounds.top + bounds.bottom) / 2,
+    }
+
+    // 4. Update the component positions
+    for (const { component, selector } of involvedComponents) {
+      const kvx = getKVar(`${selector}_x`)
+      const kvy = getKVar(`${selector}_y`)
+      component._setPositionFromLayout({
+        x: kvx.value() + globalOffset.x,
+        y: kvy.value() + globalOffset.y,
+      })
     }
   }
 }

package/lib/components/primitive-components/Hole.ts

@@ -14,7 +14,7 @@ export class Hole extends PrimitiveComponent<typeof holeProps> {
 
   getPcbSize(): { width: number; height: number } {
     const { _parsedProps: props } = this
-    return { width: props.holeDiameter, height: props.holeDiameter }
+    return { width: props.diameter, height: props.diameter }
   }
 
   doInitialPcbPrimitiveRender(): void {
@@ -22,15 +22,44 @@ export class Hole extends PrimitiveComponent<typeof holeProps> {
     const { _parsedProps: props } = this
     const position = this._getGlobalPcbPositionBeforeLayout()
 
-    const pcb_hole: PCBHole = {
-      type: "pcb_hole",
+    const inserted_hole = db.pcb_hole.insert({
       hole_shape: "round",
-      hole_diameter: props.holeDiameter,
+      // @ts-ignore
+      hole_diameter: props.diameter,
       x: position.x,
       y: position.y,
+    })
+    this.pcb_hole_id = inserted_hole.pcb_hole_id!
+  }
+
+  _getCircuitJsonBounds(): {
+    center: { x: number; y: number }
+    bounds: { left: number; top: number; right: number; bottom: number }
+    width: number
+    height: number
+  } {
+    const { db } = this.root!
+    const hole = db.pcb_hole.get(this.pcb_hole_id!)!
+    const size = this.getPcbSize()
+
+    return {
+      center: { x: hole.x, y: hole.y },
+      bounds: {
+        left: hole.x - size.width / 2,
+        top: hole.y - size.height / 2,
+        right: hole.x + size.width / 2,
+        bottom: hole.y + size.height / 2,
+      },
+      width: size.width,
+      height: size.height,
     }
+  }
 
-    const inserted_hole = db.pcb_hole.insert(pcb_hole)
-    // this.pcb_hole_id = inserted_hole.pcb_hole_id!
+  _setPositionFromLayout(newCenter: { x: number; y: number }) {
+    const { db } = this.root!
+    db.pcb_hole.update(this.pcb_hole_id!, {
+      x: newCenter.x,
+      y: newCenter.y,
+    })
   }
 }

package/lib/components/primitive-components/PlatedHole.ts

@@ -27,6 +27,37 @@ export class PlatedHole extends PrimitiveComponent<typeof platedHoleProps> {
     )
   }
 
+  _getCircuitJsonBounds(): {
+    center: { x: number; y: number }
+    bounds: { left: number; top: number; right: number; bottom: number }
+    width: number
+    height: number
+  } {
+    const { db } = this.root!
+    const platedHole = db.pcb_plated_hole.get(this.pcb_plated_hole_id!)!
+    const size = this.getPcbSize()
+
+    return {
+      center: { x: platedHole.x, y: platedHole.y },
+      bounds: {
+        left: platedHole.x - size.width / 2,
+        top: platedHole.y - size.height / 2,
+        right: platedHole.x + size.width / 2,
+        bottom: platedHole.y + size.height / 2,
+      },
+      width: size.width,
+      height: size.height,
+    }
+  }
+
+  _setPositionFromLayout(newCenter: { x: number; y: number }) {
+    const { db } = this.root!
+    db.pcb_plated_hole.update(this.pcb_plated_hole_id!, {
+      x: newCenter.x,
+      y: newCenter.y,
+    })
+  }
+
   doInitialPortMatching(): void {
     const parentPorts = (this.parent?.children ?? []).filter(
       (c) => c.componentName === "Port",
@@ -48,26 +79,22 @@ export class PlatedHole extends PrimitiveComponent<typeof platedHoleProps> {
   doInitialPcbPrimitiveRender(): void {
     const { db } = this.root!
     const { _parsedProps: props } = this
-    if (!props.portHints) return
     const position = this._getGlobalPcbPositionBeforeLayout()
     if (props.shape === "circle") {
-      const plated_hole_input: PCBPlatedHoleInput = {
+      const pcb_plated_hole = db.pcb_plated_hole.insert({
         pcb_component_id: this.parent?.pcb_component_id!,
         pcb_port_id: this.matchedPort?.pcb_port_id!,
-        layers: ["top", "bottom"],
+        // @ts-ignore - some issue with @tscircuit/soup union type
         outer_diameter: props.outerDiameter,
         hole_diameter: props.holeDiameter,
-        shape: "circle",
+        shape: "circle" as const,
         port_hints: this.getNameAndAliases(),
         x: position.x,
         y: position.y,
-        type: "pcb_plated_hole",
-      }
-
-      // @ts-ignore - some issue with soup-util types it seems
-      const pcb_plated_hole = db.pcb_plated_hole.insert(plated_hole_input)
+        layers: ["top", "bottom"],
+      })
 
-      // this.pcb_plated_hole_id = pcb_plated_hole.pcb_plated_hole_id
+      this.pcb_plated_hole_id = pcb_plated_hole.pcb_plated_hole_id
     }
   }
 }

package/lib/soup/underscorifyPinStyles.ts

@@ -1,21 +1,23 @@
-import type { SchematicPinStyles } from "@tscircuit/props"
+import type { SchematicPinStyle } from "@tscircuit/props"
 import { schematic_component } from "@tscircuit/soup"
 import { z } from "zod"
 
 type UnderscorePinStyles = z.input<typeof schematic_component>["pin_styles"]
 
 export const underscorifyPinStyles = (
-  pinStyles: SchematicPinStyles | undefined,
+  pinStyles: Record<string, SchematicPinStyle> | undefined,
 ): UnderscorePinStyles | undefined => {
   if (!pinStyles) return undefined
   const underscorePinStyles: UnderscorePinStyles = {}
 
-  for (const [pinName, pinStyle] of Object.entries(pinStyles)) {
+  for (const [pinName, pinStyle] of Object.entries(pinStyles) as Array<
+    [string, SchematicPinStyle]
+  >) {
     underscorePinStyles[pinName] = {
-      bottom_margin: pinStyle.bottomMargin,
-      left_margin: pinStyle.leftMargin,
-      right_margin: pinStyle.rightMargin,
-      top_margin: pinStyle.topMargin,
+      bottom_margin: pinStyle.bottomMargin as number,
+      left_margin: pinStyle.leftMargin as number,
+      right_margin: pinStyle.rightMargin as number,
+      top_margin: pinStyle.topMargin as number,
     }
   }
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tscircuit/core",
   "module": "index.ts",
   "type": "module",
-  "version": "0.0.32",
+  "version": "0.0.34",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "files": [
@@ -35,8 +35,8 @@
   "dependencies": {
     "@lume/kiwi": "^0.4.3",
     "@tscircuit/infgrid-ijump-astar": "^0.0.6",
-    "@tscircuit/props": "^0.0.58",
-    "@tscircuit/soup": "^0.0.58",
+    "@tscircuit/props": "^0.0.62",
+    "@tscircuit/soup": "^0.0.66",
     "@tscircuit/soup-util": "0.0.18",
     "footprinter": "^0.0.44",
     "react": "^18.3.1",