@tscircuit/props 0.0.41 → 0.0.43

package/dist/index.js

@@ -22,10 +22,6 @@ var lib_exports = {};
 __export(lib_exports, {
   boardProps: () => boardProps,
   bugProps: () => bugProps,
-  cadModelBase: () => cadModelBase,
-  cadModelJscad: () => cadModelJscad,
-  cadModelObj: () => cadModelObj,
-  cadModelStl: () => cadModelStl,
   capacitorPins: () => capacitorPins,
   capacitorProps: () => capacitorProps,
   chipProps: () => chipProps,
@@ -37,10 +33,12 @@ __export(lib_exports, {
   diodePins: () => diodePins,
   diodeProps: () => diodeProps,
   direction: () => direction,
-  distanceOrMultiplier: () => distanceOrMultiplier,
+  directionAlongEdge: () => directionAlongEdge,
+  distanceOrMultiplier: () => distanceOrMultiplier2,
   explicitPinSideDefinition: () => explicitPinSideDefinition,
   fabricationNotePathProps: () => fabricationNotePathProps,
   fabricationNoteTextProps: () => fabricationNoteTextProps,
+  footprintProp: () => footprintProp,
   footprintProps: () => footprintProps,
   groupProps: () => groupProps,
   holeProps: () => holeProps,
@@ -54,11 +52,11 @@ __export(lib_exports, {
   pcbLayoutProps: () => pcbLayoutProps,
   pcbTraceProps: () => pcbTraceProps,
   platedHoleProps: () => platedHoleProps,
+  point3: () => point3,
   portHints: () => portHints,
   portProps: () => portProps,
   portRef: () => portRef,
   powerSourceProps: () => powerSourceProps,
-  relativeDirection: () => relativeDirection,
   resistorPins: () => resistorPins,
   resistorProps: () => resistorProps,
   routeHintPointProps: () => routeHintPointProps,
@@ -73,77 +71,101 @@ __export(lib_exports, {
   silkscreenRectProps: () => silkscreenRectProps,
   silkscreenTextProps: () => silkscreenTextProps,
   smtPadProps: () => smtPadProps,
-  supplierProps: () => supplierProps,
+  supplierProps: () => supplierProps2,
   switchProps: () => switchProps,
   traceHintProps: () => traceHintProps,
   traceProps: () => traceProps,
   viaProps: () => viaProps
 });
 module.exports = __toCommonJS(lib_exports);
-var import_soup = require("@tscircuit/soup");
+var import_soup6 = require("@tscircuit/soup");
+var import_zod11 = require("zod");
+
+// lib/typecheck.ts
+var expectTypesMatch = (shouldBe) => {
+};
+
+// lib/common/direction.ts
 var import_zod = require("zod");
-var portHints = import_zod.z.array(import_zod.z.string().or(import_zod.z.number()));
 var direction = import_zod.z.enum(["up", "down", "left", "right"]);
-var relativeDirection = import_zod.z.enum([
+var directionAlongEdge = import_zod.z.enum([
   "top-to-bottom",
   "left-to-right",
   "bottom-to-top",
   "right-to-left"
 ]);
-var explicitPinSideDefinition = import_zod.z.object({
-  pins: import_zod.z.array(import_zod.z.number()),
-  direction: import_zod.z.union([
-    import_zod.z.literal("top-to-bottom"),
-    import_zod.z.literal("left-to-right"),
-    import_zod.z.literal("bottom-to-top"),
-    import_zod.z.literal("right-to-left")
-  ])
+expectTypesMatch(true);
+expectTypesMatch(true);
+
+// lib/common/portHints.ts
+var import_zod2 = require("zod");
+var portHints = import_zod2.z.array(import_zod2.z.string().or(import_zod2.z.number()));
+expectTypesMatch(true);
+
+// lib/common/layout.ts
+var import_zod6 = require("zod");
+var import_soup2 = require("@tscircuit/soup");
+
+// lib/common/point3.ts
+var import_soup = require("@tscircuit/soup");
+var import_zod3 = require("zod");
+var point3 = import_zod3.z.object({
+  x: import_soup.distance,
+  y: import_soup.distance,
+  z: import_soup.distance
 });
-var pcbLayoutProps = import_zod.z.object({
-  pcbX: import_soup.distance,
-  pcbY: import_soup.distance,
-  pcbRotation: import_soup.rotation.optional(),
-  layer: import_soup.layer_ref.optional()
-});
-var commonLayoutProps = import_zod.z.object({
-  pcbX: import_soup.distance.optional(),
-  pcbY: import_soup.distance.optional(),
-  pcbRotation: import_soup.rotation.optional(),
-  schX: import_soup.distance.optional(),
-  schY: import_soup.distance.optional(),
-  schRotation: import_soup.rotation.optional(),
-  layer: import_soup.layer_ref.optional(),
-  // TODO pull in literals from @tscircuit/footprint
-  // TODO footprint can be a string or react child
-  footprint: import_zod.z.custom((v) => true).optional()
-});
-var supplierProps = import_zod.z.object({
-  supplierPartNumbers: import_zod.z.record(import_soup.supplier_name, import_zod.z.array(import_zod.z.string())).optional()
-});
-var point3 = import_zod.z.object({
-  x: import_zod.z.union([import_zod.z.number(), import_zod.z.string()]),
-  y: import_zod.z.union([import_zod.z.number(), import_zod.z.string()]),
-  z: import_zod.z.union([import_zod.z.number(), import_zod.z.string()])
-});
-var cadModelBase = import_zod.z.object({
-  rotationOffset: import_zod.z.number().or(point3).optional(),
+
+// lib/common/cadModel.ts
+var import_zod4 = require("zod");
+var rotationPoint3 = import_zod4.z.object({
+  x: import_zod4.z.union([import_zod4.z.number(), import_zod4.z.string()]),
+  y: import_zod4.z.union([import_zod4.z.number(), import_zod4.z.string()]),
+  z: import_zod4.z.union([import_zod4.z.number(), import_zod4.z.string()])
+});
+var cadModelBase = import_zod4.z.object({
+  rotationOffset: import_zod4.z.number().or(rotationPoint3).optional(),
   positionOffset: point3.optional(),
   size: point3.optional()
 });
 var cadModelStl = cadModelBase.extend({
-  stlUrl: import_zod.z.string()
+  stlUrl: import_zod4.z.string()
 });
 var cadModelObj = cadModelBase.extend({
-  objUrl: import_zod.z.string(),
-  mtlUrl: import_zod.z.string().optional()
+  objUrl: import_zod4.z.string(),
+  mtlUrl: import_zod4.z.string().optional()
 });
 var cadModelJscad = cadModelBase.extend({
-  jscad: import_zod.z.any()
+  jscad: import_zod4.z.any()
+});
+
+// lib/common/footprintProp.ts
+var import_zod5 = require("zod");
+var footprintProp = import_zod5.z.custom((v) => true);
+
+// lib/common/layout.ts
+var pcbLayoutProps = import_zod6.z.object({
+  pcbX: import_soup2.distance,
+  pcbY: import_soup2.distance,
+  pcbRotation: import_soup2.rotation.optional(),
+  layer: import_soup2.layer_ref.optional()
+});
+var commonLayoutProps = import_zod6.z.object({
+  pcbX: import_soup2.distance.optional(),
+  pcbY: import_soup2.distance.optional(),
+  pcbRotation: import_soup2.rotation.optional(),
+  schX: import_soup2.distance.optional(),
+  schY: import_soup2.distance.optional(),
+  schRotation: import_soup2.rotation.optional(),
+  layer: import_soup2.layer_ref.optional(),
+  footprint: footprintProp.optional()
+});
+var supplierProps = import_zod6.z.object({
+  supplierPartNumbers: import_zod6.z.record(import_soup2.supplier_name, import_zod6.z.array(import_zod6.z.string())).optional()
 });
 var commonComponentProps = commonLayoutProps.merge(supplierProps).extend({
-  name: import_zod.z.string(),
-  cadModel: import_zod.z.union([cadModelStl, cadModelObj, cadModelJscad]).optional(),
-  children: import_zod.z.any().optional()
+  name: import_zod6.z.string(),
+  cadModel: import_zod6.z.union([cadModelStl, cadModelObj, cadModelJscad]).optional(),
+  children: import_zod6.z.any().optional()
 });
 var lrPins = ["pin1", "left", "pin2", "right"];
 var lrPolarPins = [
@@ -156,260 +178,293 @@ var lrPolarPins = [
   "cathode",
   "neg"
 ];
-var resistorProps = commonComponentProps.extend({
-  resistance: import_soup.resistance
-});
-var resistorPins = lrPins;
-var capacitorProps = commonComponentProps.extend({
-  capacitance: import_soup.capacitance
-});
-var capacitorPins = lrPolarPins;
-var inductorProps = commonComponentProps.extend({
-  inductance: import_soup.inductance
-});
-var inductorPins = lrPins;
-var diodeProps = commonComponentProps.extend({});
-var diodePins = lrPolarPins;
-var ledProps = commonComponentProps.extend({
-  color: import_zod.z.string().optional()
+var distanceOrMultiplier = import_soup2.distance.or(import_zod6.z.enum(["2x", "3x", "4x"]));
+
+// lib/common/schematicPinDefinitions.ts
+var import_zod7 = require("zod");
+var explicitPinSideDefinition = import_zod7.z.object({
+  pins: import_zod7.z.array(import_zod7.z.number()),
+  direction: import_zod7.z.union([
+    import_zod7.z.literal("top-to-bottom"),
+    import_zod7.z.literal("left-to-right"),
+    import_zod7.z.literal("bottom-to-top"),
+    import_zod7.z.literal("right-to-left")
+  ])
 });
-var ledPins = lrPolarPins;
-var switchProps = commonComponentProps.extend({
-  ftype: import_zod.z.literal("switch"),
-  switchType: import_zod.z.enum(["spst"]).default("spst"),
-  isNormallyClosed: import_zod.z.boolean().default(false)
-});
-var boardProps = import_zod.z.object({
-  width: import_soup.distance,
-  height: import_soup.distance,
-  outline: import_zod.z.array(import_soup.point).optional(),
-  pcbX: import_soup.distance.optional().default(0),
-  pcbY: import_soup.distance.optional().default(0),
-  layout: import_zod.z.any().optional(),
-  routingDisabled: import_zod.z.boolean().optional(),
-  children: import_zod.z.any()
-});
-var distanceOrMultiplier = import_soup.distance.or(import_zod.z.enum(["2x", "3x", "4x"]));
-var schematicPortArrangement = import_zod.z.object({
-  leftSize: import_zod.z.number().optional().describe("@deprecated, use leftPinCount"),
-  topSize: import_zod.z.number().optional().describe("@deprecated, use topPinCount"),
-  rightSize: import_zod.z.number().optional().describe("@deprecated, use rightPinCount"),
-  bottomSize: import_zod.z.number().optional().describe("@deprecated, use bottomPinCount")
+var schematicPortArrangement = import_zod7.z.object({
+  leftSize: import_zod7.z.number().optional().describe("@deprecated, use leftPinCount"),
+  topSize: import_zod7.z.number().optional().describe("@deprecated, use topPinCount"),
+  rightSize: import_zod7.z.number().optional().describe("@deprecated, use rightPinCount"),
+  bottomSize: import_zod7.z.number().optional().describe("@deprecated, use bottomPinCount")
 }).or(
-  import_zod.z.object({
-    leftPinCount: import_zod.z.number().optional(),
-    rightPinCount: import_zod.z.number().optional(),
-    topPinCount: import_zod.z.number().optional(),
-    bottomPinCount: import_zod.z.number().optional()
+  import_zod7.z.object({
+    leftPinCount: import_zod7.z.number().optional(),
+    rightPinCount: import_zod7.z.number().optional(),
+    topPinCount: import_zod7.z.number().optional(),
+    bottomPinCount: import_zod7.z.number().optional()
   })
 ).or(
-  import_zod.z.object({
+  import_zod7.z.object({
     leftSide: explicitPinSideDefinition.optional(),
     rightSide: explicitPinSideDefinition.optional(),
     topSide: explicitPinSideDefinition.optional(),
     bottomSide: explicitPinSideDefinition.optional()
   })
 );
+
+// lib/components/board.ts
+var import_zod9 = require("zod");
+var import_soup4 = require("@tscircuit/soup");
+
+// lib/common/point.ts
+var import_soup3 = require("@tscircuit/soup");
+var import_zod8 = require("zod");
+var point = import_zod8.z.object({
+  x: import_soup3.distance,
+  y: import_soup3.distance
+});
+
+// lib/components/board.ts
+var boardProps = import_zod9.z.object({
+  width: import_soup4.distance.optional(),
+  height: import_soup4.distance.optional(),
+  outline: import_zod9.z.array(point).optional(),
+  pcbX: import_soup4.distance.optional().default(0),
+  pcbY: import_soup4.distance.optional().default(0),
+  layout: import_zod9.z.any().optional(),
+  routingDisabled: import_zod9.z.boolean().optional(),
+  children: import_zod9.z.any()
+});
+expectTypesMatch(true);
+
+// lib/components/chip.ts
+var import_zod10 = require("zod");
+var import_soup5 = require("@tscircuit/soup");
 var chipProps = commonComponentProps.extend({
-  manufacturerPartNumber: import_zod.z.string().optional(),
-  pinLabels: import_zod.z.record(import_zod.z.number().or(import_zod.z.string()), import_zod.z.string()).optional(),
+  manufacturerPartNumber: import_zod10.z.string().optional(),
+  pinLabels: import_zod10.z.record(import_zod10.z.number().or(import_zod10.z.string()), import_zod10.z.string()).optional(),
   schPortArrangement: schematicPortArrangement.optional(),
-  schPinStyle: import_zod.z.record(
-    import_zod.z.object({
-      leftMargin: import_soup.distance.optional(),
-      rightMargin: import_soup.distance.optional(),
-      topMargin: import_soup.distance.optional(),
-      bottomMargin: import_soup.distance.optional()
+  schPinStyle: import_zod10.z.record(
+    import_zod10.z.object({
+      leftMargin: import_soup5.distance.optional(),
+      rightMargin: import_soup5.distance.optional(),
+      topMargin: import_soup5.distance.optional(),
+      bottomMargin: import_soup5.distance.optional()
     })
   ).optional(),
-  schPinSpacing: distanceOrMultiplier.or(import_zod.z.literal("auto")).optional().default("auto"),
-  schWidth: import_soup.distance.or(import_zod.z.literal("auto")).optional().default("auto"),
-  schHeight: import_soup.distance.or(import_zod.z.literal("auto")).optional().default("auto")
+  schPinSpacing: import_soup5.distance.or(import_zod10.z.literal("auto")).optional().default("auto"),
+  schWidth: import_soup5.distance.or(import_zod10.z.literal("auto")).optional().default("auto"),
+  schHeight: import_soup5.distance.or(import_zod10.z.literal("auto")).optional().default("auto")
 });
 var bugProps = chipProps;
+
+// lib/index.ts
+var supplierProps2 = import_zod11.z.object({
+  supplierPartNumbers: import_zod11.z.record(import_soup6.supplier_name, import_zod11.z.array(import_zod11.z.string())).optional()
+});
+var resistorProps = commonComponentProps.extend({
+  resistance: import_soup6.resistance
+});
+var resistorPins = lrPins;
+var capacitorProps = commonComponentProps.extend({
+  capacitance: import_soup6.capacitance
+});
+var capacitorPins = lrPolarPins;
+var inductorProps = commonComponentProps.extend({
+  inductance: import_soup6.inductance
+});
+var inductorPins = lrPins;
+var diodeProps = commonComponentProps.extend({});
+var diodePins = lrPolarPins;
+var ledProps = commonComponentProps.extend({
+  color: import_zod11.z.string().optional()
+});
+var ledPins = lrPolarPins;
+var switchProps = commonComponentProps.extend({
+  ftype: import_zod11.z.literal("switch"),
+  switchType: import_zod11.z.enum(["spst"]).default("spst"),
+  isNormallyClosed: import_zod11.z.boolean().default(false)
+});
+var distanceOrMultiplier2 = import_soup6.distance.or(import_zod11.z.enum(["2x", "3x", "4x"]));
 var viaProps = commonLayoutProps.extend({
-  fromLayer: import_soup.layer_ref,
-  toLayer: import_soup.layer_ref,
-  holeDiameter: import_soup.distance,
-  outerDiameter: import_soup.distance
+  fromLayer: import_soup6.layer_ref,
+  toLayer: import_soup6.layer_ref,
+  holeDiameter: import_soup6.distance,
+  outerDiameter: import_soup6.distance
 });
 var netAliasProps = commonLayoutProps.extend({
-  net: import_zod.z.string().optional()
+  net: import_zod11.z.string().optional()
 });
-var portRef = import_zod.z.union([
-  import_zod.z.string(),
-  import_zod.z.custom(
+var portRef = import_zod11.z.union([
+  import_zod11.z.string(),
+  import_zod11.z.custom(
     (v) => Boolean(v.getPortSelector)
   )
 ]);
-var traceProps = import_zod.z.object({
-  path: import_zod.z.array(portRef),
-  thickness: import_soup.distance.optional(),
-  schematicRouteHints: import_zod.z.array(import_soup.point).optional(),
-  pcbRouteHints: import_zod.z.array(import_soup.route_hint_point).optional()
+var traceProps = import_zod11.z.object({
+  path: import_zod11.z.array(portRef),
+  thickness: import_soup6.distance.optional(),
+  schematicRouteHints: import_zod11.z.array(import_soup6.point).optional(),
+  pcbRouteHints: import_zod11.z.array(import_soup6.route_hint_point).optional()
 }).or(
-  import_zod.z.object({
+  import_zod11.z.object({
     from: portRef,
     to: portRef,
-    thickness: import_soup.distance.optional(),
-    schematicRouteHints: import_zod.z.array(import_soup.point).optional(),
-    pcbRouteHints: import_zod.z.array(import_soup.route_hint_point).optional()
+    thickness: import_soup6.distance.optional(),
+    schematicRouteHints: import_zod11.z.array(import_soup6.point).optional(),
+    pcbRouteHints: import_zod11.z.array(import_soup6.route_hint_point).optional()
   })
 );
-var smtPadProps = import_zod.z.union([
+var smtPadProps = import_zod11.z.union([
   pcbLayoutProps.omit({ pcbRotation: true }).extend({
-    shape: import_zod.z.literal("circle"),
-    radius: import_soup.distance.optional(),
+    shape: import_zod11.z.literal("circle"),
+    radius: import_soup6.distance.optional(),
     portHints: portHints.optional()
   }),
   pcbLayoutProps.omit({ pcbRotation: true }).extend({
-    shape: import_zod.z.literal("rect"),
-    width: import_soup.distance.optional(),
-    height: import_soup.distance.optional(),
+    shape: import_zod11.z.literal("rect"),
+    width: import_soup6.distance.optional(),
+    height: import_soup6.distance.optional(),
     portHints: portHints.optional()
   })
 ]);
-var platedHoleProps = import_zod.z.union([
+var platedHoleProps = import_zod11.z.union([
   pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
-    shape: import_zod.z.literal("circle"),
-    holeDiameter: import_soup.distance,
-    outerDiameter: import_soup.distance,
+    shape: import_zod11.z.literal("circle"),
+    holeDiameter: import_soup6.distance,
+    outerDiameter: import_soup6.distance,
     portHints: portHints.optional()
   }),
   pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
-    shape: import_zod.z.literal("oval"),
-    outerWidth: import_soup.distance,
-    outerHeight: import_soup.distance,
-    innerWidth: import_soup.distance,
-    innerHeight: import_soup.distance,
+    shape: import_zod11.z.literal("oval"),
+    outerWidth: import_soup6.distance,
+    outerHeight: import_soup6.distance,
+    innerWidth: import_soup6.distance,
+    innerHeight: import_soup6.distance,
     portHints: portHints.optional()
   })
 ]);
 var holeProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  holeDiameter: import_soup.distance
-});
-var schematicBoxProps = import_zod.z.object({
-  schX: import_soup.distance,
-  schY: import_soup.distance,
-  width: import_soup.distance,
-  height: import_soup.distance
-});
-var schematicTextProps = import_zod.z.object({
-  schX: import_soup.distance,
-  schY: import_soup.distance,
-  text: import_zod.z.string()
-});
-var schematicLineProps = import_zod.z.object({
-  x1: import_soup.distance,
-  y1: import_soup.distance,
-  x2: import_soup.distance,
-  y2: import_soup.distance
-});
-var schematicPathProps = import_zod.z.object({
-  points: import_zod.z.array(import_soup.point),
-  isFilled: import_zod.z.boolean().optional().default(false),
-  fillColor: import_zod.z.enum(["red", "blue"]).optional()
-});
-var constraintProps = import_zod.z.union([
-  import_zod.z.object({
-    type: import_zod.z.literal("xdist"),
-    dist: import_soup.distance,
-    left: import_zod.z.string(),
-    right: import_zod.z.string()
+  holeDiameter: import_soup6.distance
+});
+var schematicBoxProps = import_zod11.z.object({
+  schX: import_soup6.distance,
+  schY: import_soup6.distance,
+  width: import_soup6.distance,
+  height: import_soup6.distance
+});
+var schematicTextProps = import_zod11.z.object({
+  schX: import_soup6.distance,
+  schY: import_soup6.distance,
+  text: import_zod11.z.string()
+});
+var schematicLineProps = import_zod11.z.object({
+  x1: import_soup6.distance,
+  y1: import_soup6.distance,
+  x2: import_soup6.distance,
+  y2: import_soup6.distance
+});
+var schematicPathProps = import_zod11.z.object({
+  points: import_zod11.z.array(import_soup6.point),
+  isFilled: import_zod11.z.boolean().optional().default(false),
+  fillColor: import_zod11.z.enum(["red", "blue"]).optional()
+});
+var constraintProps = import_zod11.z.union([
+  import_zod11.z.object({
+    type: import_zod11.z.literal("xdist"),
+    dist: import_soup6.distance,
+    left: import_zod11.z.string(),
+    right: import_zod11.z.string()
   }),
-  import_zod.z.object({
-    type: import_zod.z.literal("ydist"),
-    dist: import_soup.distance,
-    top: import_zod.z.string(),
-    bottom: import_zod.z.string()
+  import_zod11.z.object({
+    type: import_zod11.z.literal("ydist"),
+    dist: import_soup6.distance,
+    top: import_zod11.z.string(),
+    bottom: import_zod11.z.string()
   })
 ]);
-var constrainedLayoutProps = import_zod.z.object({});
-var footprintProps = import_zod.z.object({});
+var constrainedLayoutProps = import_zod11.z.object({});
+var footprintProps = import_zod11.z.object({});
 var componentProps = commonComponentProps;
 var groupProps = commonLayoutProps.extend({
-  name: import_zod.z.string().optional(),
-  layout: import_zod.z.custom((v) => true).optional(),
-  children: import_zod.z.any().optional(),
-  routingDisabled: import_zod.z.boolean().optional()
+  name: import_zod11.z.string().optional(),
+  layout: import_zod11.z.custom((v) => true).optional(),
+  children: import_zod11.z.any().optional(),
+  routingDisabled: import_zod11.z.boolean().optional()
 });
 var powerSourceProps = commonComponentProps.extend({
-  voltage: import_soup.voltage
+  voltage: import_soup6.voltage
 });
 var portProps = commonLayoutProps.extend({
-  name: import_zod.z.string(),
-  pinNumber: import_zod.z.number().optional(),
-  aliases: import_zod.z.array(import_zod.z.string()).optional(),
+  name: import_zod11.z.string(),
+  pinNumber: import_zod11.z.number().optional(),
+  aliases: import_zod11.z.array(import_zod11.z.string()).optional(),
   direction
 });
 var silkscreenTextProps = pcbLayoutProps.extend({
-  text: import_zod.z.string(),
-  anchorAlignment: import_zod.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
-  font: import_zod.z.enum(["tscircuit2024"]).optional(),
-  fontSize: import_soup.length.optional()
+  text: import_zod11.z.string(),
+  anchorAlignment: import_zod11.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  font: import_zod11.z.enum(["tscircuit2024"]).optional(),
+  fontSize: import_soup6.length.optional()
 });
 var silkscreenPathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  route: import_zod.z.array(import_soup.route_hint_point),
-  strokeWidth: import_soup.length.optional()
+  route: import_zod11.z.array(import_soup6.route_hint_point),
+  strokeWidth: import_soup6.length.optional()
 });
 var silkscreenLineProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  strokeWidth: import_soup.distance,
-  x1: import_soup.distance,
-  y1: import_soup.distance,
-  x2: import_soup.distance,
-  y2: import_soup.distance
+  strokeWidth: import_soup6.distance,
+  x1: import_soup6.distance,
+  y1: import_soup6.distance,
+  x2: import_soup6.distance,
+  y2: import_soup6.distance
 });
 var silkscreenRectProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  isFilled: import_zod.z.boolean().optional(),
-  isOutline: import_zod.z.boolean().optional(),
-  strokeWidth: import_soup.distance.optional(),
-  width: import_soup.distance,
-  height: import_soup.distance
+  isFilled: import_zod11.z.boolean().optional(),
+  isOutline: import_zod11.z.boolean().optional(),
+  strokeWidth: import_soup6.distance.optional(),
+  width: import_soup6.distance,
+  height: import_soup6.distance
 });
 var silkscreenCircleProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  isFilled: import_zod.z.boolean().optional(),
-  isOutline: import_zod.z.boolean().optional(),
-  strokeWidth: import_soup.distance.optional(),
-  radius: import_soup.distance
-});
-var routeHintPointProps = import_zod.z.object({
-  x: import_soup.distance,
-  y: import_soup.distance,
-  via: import_zod.z.boolean().optional(),
-  toLayer: import_soup.layer_ref.optional()
-});
-var traceHintProps = import_zod.z.object({
-  for: import_zod.z.string().optional().describe(
+  isFilled: import_zod11.z.boolean().optional(),
+  isOutline: import_zod11.z.boolean().optional(),
+  strokeWidth: import_soup6.distance.optional(),
+  radius: import_soup6.distance
+});
+var routeHintPointProps = import_zod11.z.object({
+  x: import_soup6.distance,
+  y: import_soup6.distance,
+  via: import_zod11.z.boolean().optional(),
+  toLayer: import_soup6.layer_ref.optional()
+});
+var traceHintProps = import_zod11.z.object({
+  for: import_zod11.z.string().optional().describe(
     "Selector for the port you're targeting, not required if you're inside a trace"
   ),
-  order: import_zod.z.number().optional(),
-  offset: import_soup.route_hint_point.or(routeHintPointProps).optional(),
-  offsets: import_zod.z.array(import_soup.route_hint_point).or(import_zod.z.array(routeHintPointProps)).optional(),
-  traceWidth: import_zod.z.number().optional()
+  order: import_zod11.z.number().optional(),
+  offset: import_soup6.route_hint_point.or(routeHintPointProps).optional(),
+  offsets: import_zod11.z.array(import_soup6.route_hint_point).or(import_zod11.z.array(routeHintPointProps)).optional(),
+  traceWidth: import_zod11.z.number().optional()
 });
-var pcbTraceProps = import_zod.z.object({
-  layer: import_zod.z.string().optional(),
-  thickness: import_soup.distance.optional(),
-  route: import_zod.z.array(import_soup.route_hint_point)
+var pcbTraceProps = import_zod11.z.object({
+  layer: import_zod11.z.string().optional(),
+  thickness: import_soup6.distance.optional(),
+  route: import_zod11.z.array(import_soup6.route_hint_point)
 });
 var fabricationNoteTextProps = pcbLayoutProps.extend({
-  text: import_zod.z.string(),
-  anchorAlignment: import_zod.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
-  font: import_zod.z.enum(["tscircuit2024"]).optional(),
-  fontSize: import_soup.length.optional()
+  text: import_zod11.z.string(),
+  anchorAlignment: import_zod11.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  font: import_zod11.z.enum(["tscircuit2024"]).optional(),
+  fontSize: import_soup6.length.optional()
 });
 var fabricationNotePathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  route: import_zod.z.array(import_soup.route_hint_point),
-  strokeWidth: import_soup.length.optional()
+  route: import_zod11.z.array(import_soup6.route_hint_point),
+  strokeWidth: import_soup6.length.optional()
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   boardProps,
   bugProps,
-  cadModelBase,
-  cadModelJscad,
-  cadModelObj,
-  cadModelStl,
   capacitorPins,
   capacitorProps,
   chipProps,
@@ -421,10 +476,12 @@ var fabricationNotePathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcb
   diodePins,
   diodeProps,
   direction,
+  directionAlongEdge,
   distanceOrMultiplier,
   explicitPinSideDefinition,
   fabricationNotePathProps,
   fabricationNoteTextProps,
+  footprintProp,
   footprintProps,
   groupProps,
   holeProps,
@@ -438,11 +495,11 @@ var fabricationNotePathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcb
   pcbLayoutProps,
   pcbTraceProps,
   platedHoleProps,
+  point3,
   portHints,
   portProps,
   portRef,
   powerSourceProps,
-  relativeDirection,
   resistorPins,
   resistorProps,
   routeHintPointProps,