@tscircuit/props 0.0.74 → 0.0.76

package/dist/index.js

@@ -101,8 +101,8 @@ __export(lib_exports, {
   viaProps: () => viaProps
 });
 module.exports = __toCommonJS(lib_exports);
-var import_soup14 = require("@tscircuit/soup");
-var import_zod26 = require("zod");
+var import_soup15 = require("@tscircuit/soup");
+var import_zod27 = require("zod");
 
 // lib/typecheck.ts
 var expectTypesMatch = (shouldBe) => {
@@ -279,7 +279,8 @@ var boardProps = import_zod10.z.object({
   layout: import_zod10.z.any().optional(),
   routingDisabled: import_zod10.z.boolean().optional(),
   children: import_zod10.z.any(),
-  defaultTraceWidth: import_soup5.distance.optional()
+  defaultTraceWidth: import_soup5.distance.optional(),
+  schAutoLayoutEnabled: import_zod10.z.boolean().optional()
 });
 expectTypesMatch(true);
 
@@ -313,111 +314,144 @@ var jumperProps = commonComponentProps.extend({
 });
 expectTypesMatch(true);
 
-// lib/components/resistor.ts
+// lib/components/platedhole.ts
 var import_zod13 = require("zod");
 var import_soup8 = require("@tscircuit/soup");
+var platedHoleProps = import_zod13.z.discriminatedUnion("shape", [
+  pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
+    name: import_zod13.z.string().optional(),
+    shape: import_zod13.z.literal("circle"),
+    holeDiameter: import_soup8.distance,
+    outerDiameter: import_soup8.distance,
+    portHints: portHints.optional()
+  }),
+  pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
+    name: import_zod13.z.string().optional(),
+    shape: import_zod13.z.literal("oval"),
+    outerWidth: import_soup8.distance,
+    outerHeight: import_soup8.distance,
+    innerWidth: import_soup8.distance,
+    innerHeight: import_soup8.distance,
+    portHints: portHints.optional()
+  }),
+  pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
+    name: import_zod13.z.string().optional(),
+    shape: import_zod13.z.literal("pill"),
+    outerWidth: import_soup8.distance,
+    outerHeight: import_soup8.distance,
+    innerWidth: import_soup8.distance,
+    innerHeight: import_soup8.distance,
+    portHints: portHints.optional()
+  })
+]);
+expectTypesMatch(true);
+
+// lib/components/resistor.ts
+var import_zod14 = require("zod");
+var import_soup9 = require("@tscircuit/soup");
 var resistorProps = commonComponentProps.extend({
-  resistance: import_soup8.resistance,
-  pullupFor: import_zod13.z.string().optional(),
-  pullupTo: import_zod13.z.string().optional(),
-  pulldownFor: import_zod13.z.string().optional(),
-  pulldownTo: import_zod13.z.string().optional()
+  resistance: import_soup9.resistance,
+  pullupFor: import_zod14.z.string().optional(),
+  pullupTo: import_zod14.z.string().optional(),
+  pulldownFor: import_zod14.z.string().optional(),
+  pulldownTo: import_zod14.z.string().optional()
 });
 var resistorPins = lrPins;
 expectTypesMatch(true);
 
 // lib/components/capacitor.ts
-var import_zod14 = require("zod");
-var import_soup9 = require("@tscircuit/soup");
+var import_zod15 = require("zod");
+var import_soup10 = require("@tscircuit/soup");
 var capacitorProps = commonComponentProps.extend({
-  capacitance: import_soup9.capacitance,
-  decouplingFor: import_zod14.z.string().optional(),
-  decouplingTo: import_zod14.z.string().optional(),
-  bypassFor: import_zod14.z.string().optional(),
-  bypassTo: import_zod14.z.string().optional()
+  capacitance: import_soup10.capacitance,
+  decouplingFor: import_zod15.z.string().optional(),
+  decouplingTo: import_zod15.z.string().optional(),
+  bypassFor: import_zod15.z.string().optional(),
+  bypassTo: import_zod15.z.string().optional()
 });
 var capacitorPins = lrPolarPins;
 expectTypesMatch(true);
 
 // lib/components/group.ts
-var import_zod15 = require("zod");
-var import_soup10 = require("@tscircuit/soup");
+var import_zod16 = require("zod");
+var import_soup11 = require("@tscircuit/soup");
 var baseGroupProps = commonLayoutProps.extend({
-  name: import_zod15.z.string().optional(),
-  children: import_zod15.z.any().optional()
+  name: import_zod16.z.string().optional(),
+  children: import_zod16.z.any().optional()
 });
 var subcircuitGroupProps = baseGroupProps.extend({
-  subcircuit: import_zod15.z.literal(true),
-  layout: import_zod15.z.custom((v) => true).optional(),
-  routingDisabled: import_zod15.z.boolean().optional(),
-  defaultTraceWidth: import_soup10.length.optional()
+  subcircuit: import_zod16.z.literal(true),
+  layout: import_zod16.z.custom((v) => true).optional(),
+  schAutoLayoutEnabled: import_zod16.z.boolean().optional(),
+  routingDisabled: import_zod16.z.boolean().optional(),
+  defaultTraceWidth: import_soup11.length.optional()
 });
-var groupProps = import_zod15.z.union([baseGroupProps, subcircuitGroupProps]);
+var groupProps = import_zod16.z.union([baseGroupProps, subcircuitGroupProps]);
 expectTypesMatch(true);
 expectTypesMatch(true);
 expectTypesMatch(true);
 
 // lib/components/net.ts
-var import_zod16 = require("zod");
-var netProps = import_zod16.z.object({
-  name: import_zod16.z.string()
+var import_zod17 = require("zod");
+var netProps = import_zod17.z.object({
+  name: import_zod17.z.string()
 });
 expectTypesMatch(true);
 
 // lib/components/constrainedlayout.ts
-var import_zod17 = require("zod");
-var constrainedLayoutProps = import_zod17.z.object({
-  name: import_zod17.z.string().optional(),
-  pcbOnly: import_zod17.z.boolean().optional(),
-  schOnly: import_zod17.z.boolean().optional()
+var import_zod18 = require("zod");
+var constrainedLayoutProps = import_zod18.z.object({
+  name: import_zod18.z.string().optional(),
+  pcbOnly: import_zod18.z.boolean().optional(),
+  schOnly: import_zod18.z.boolean().optional()
 });
 expectTypesMatch(true);
 
 // lib/common/distance.ts
-var import_zod18 = require("zod");
-var import_soup11 = require("@tscircuit/soup");
+var import_zod19 = require("zod");
+var import_soup12 = require("@tscircuit/soup");
 
 // lib/components/constraint.ts
-var import_zod19 = require("zod");
-var pcbXDistConstraintProps = import_zod19.z.object({
-  pcb: import_zod19.z.literal(true).optional(),
-  xDist: import_soup11.distance,
-  left: import_zod19.z.string(),
-  right: import_zod19.z.string(),
-  edgeToEdge: import_zod19.z.literal(true).optional(),
-  centerToCenter: import_zod19.z.literal(true).optional()
+var import_zod20 = require("zod");
+var pcbXDistConstraintProps = import_zod20.z.object({
+  pcb: import_zod20.z.literal(true).optional(),
+  xDist: import_soup12.distance,
+  left: import_zod20.z.string(),
+  right: import_zod20.z.string(),
+  edgeToEdge: import_zod20.z.literal(true).optional(),
+  centerToCenter: import_zod20.z.literal(true).optional()
 });
 expectTypesMatch(
   true
 );
-var pcbYDistConstraintProps = import_zod19.z.object({
-  pcb: import_zod19.z.literal(true).optional(),
-  yDist: import_soup11.distance,
-  top: import_zod19.z.string(),
-  bottom: import_zod19.z.string(),
-  edgeToEdge: import_zod19.z.literal(true).optional(),
-  centerToCenter: import_zod19.z.literal(true).optional()
+var pcbYDistConstraintProps = import_zod20.z.object({
+  pcb: import_zod20.z.literal(true).optional(),
+  yDist: import_soup12.distance,
+  top: import_zod20.z.string(),
+  bottom: import_zod20.z.string(),
+  edgeToEdge: import_zod20.z.literal(true).optional(),
+  centerToCenter: import_zod20.z.literal(true).optional()
 });
 expectTypesMatch(
   true
 );
-var pcbSameYConstraintProps = import_zod19.z.object({
-  pcb: import_zod19.z.literal(true).optional(),
-  sameY: import_zod19.z.literal(true).optional(),
-  for: import_zod19.z.array(import_zod19.z.string())
+var pcbSameYConstraintProps = import_zod20.z.object({
+  pcb: import_zod20.z.literal(true).optional(),
+  sameY: import_zod20.z.literal(true).optional(),
+  for: import_zod20.z.array(import_zod20.z.string())
 });
 expectTypesMatch(
   true
 );
-var pcbSameXConstraintProps = import_zod19.z.object({
-  pcb: import_zod19.z.literal(true).optional(),
-  sameX: import_zod19.z.literal(true).optional(),
-  for: import_zod19.z.array(import_zod19.z.string())
+var pcbSameXConstraintProps = import_zod20.z.object({
+  pcb: import_zod20.z.literal(true).optional(),
+  sameX: import_zod20.z.literal(true).optional(),
+  for: import_zod20.z.array(import_zod20.z.string())
 });
 expectTypesMatch(
   true
 );
-var constraintProps = import_zod19.z.union([
+var constraintProps = import_zod20.z.union([
   pcbXDistConstraintProps,
   pcbYDistConstraintProps,
   pcbSameYConstraintProps,
@@ -426,48 +460,48 @@ var constraintProps = import_zod19.z.union([
 expectTypesMatch(true);
 
 // lib/components/smtpad.ts
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 var rectSmtPadProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: import_zod20.z.literal("rect"),
-  width: import_soup11.distance,
-  height: import_soup11.distance,
+  shape: import_zod21.z.literal("rect"),
+  width: import_soup12.distance,
+  height: import_soup12.distance,
   portHints: portHints.optional()
 });
 expectTypesMatch(true);
 var circleSmtPadProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: import_zod20.z.literal("circle"),
-  radius: import_soup11.distance,
+  shape: import_zod21.z.literal("circle"),
+  radius: import_soup12.distance,
   portHints: portHints.optional()
 });
 expectTypesMatch(true);
-var smtPadProps = import_zod20.z.union([circleSmtPadProps, rectSmtPadProps]);
+var smtPadProps = import_zod21.z.union([circleSmtPadProps, rectSmtPadProps]);
 expectTypesMatch(true);
 
 // lib/components/solderpaste.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 var rectSolderPasteProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: import_zod21.z.literal("rect"),
-  width: import_soup11.distance,
-  height: import_soup11.distance
+  shape: import_zod22.z.literal("rect"),
+  width: import_soup12.distance,
+  height: import_soup12.distance
 });
 expectTypesMatch(true);
 var circleSolderPasteProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: import_zod21.z.literal("circle"),
-  radius: import_soup11.distance
+  shape: import_zod22.z.literal("circle"),
+  radius: import_soup12.distance
 });
 expectTypesMatch(true);
-var solderPasteProps = import_zod21.z.union([
+var solderPasteProps = import_zod22.z.union([
   circleSolderPasteProps,
   rectSolderPasteProps
 ]);
 expectTypesMatch(true);
 
 // lib/components/hole.ts
-var import_zod22 = require("zod");
+var import_zod23 = require("zod");
 var holeProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  name: import_zod22.z.string().optional(),
-  diameter: import_soup11.distance.optional(),
-  radius: import_soup11.distance.optional()
+  name: import_zod23.z.string().optional(),
+  diameter: import_soup12.distance.optional(),
+  radius: import_soup12.distance.optional()
 }).transform((d) => ({
   ...d,
   diameter: d.diameter ?? 2 * d.radius,
@@ -476,23 +510,23 @@ var holeProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
 expectTypesMatch(true);
 
 // lib/components/trace.ts
-var import_zod23 = require("zod");
-var import_soup12 = require("@tscircuit/soup");
-var portRef = import_zod23.z.union([
-  import_zod23.z.string(),
-  import_zod23.z.custom(
+var import_zod24 = require("zod");
+var import_soup13 = require("@tscircuit/soup");
+var portRef = import_zod24.z.union([
+  import_zod24.z.string(),
+  import_zod24.z.custom(
     (v) => Boolean(v.getPortSelector)
   )
 ]);
-var baseTraceProps = import_zod23.z.object({
-  key: import_zod23.z.string().optional(),
-  thickness: import_soup12.distance.optional(),
-  schematicRouteHints: import_zod23.z.array(point).optional(),
-  pcbRouteHints: import_zod23.z.array(import_soup12.route_hint_point).optional()
+var baseTraceProps = import_zod24.z.object({
+  key: import_zod24.z.string().optional(),
+  thickness: import_soup13.distance.optional(),
+  schematicRouteHints: import_zod24.z.array(point).optional(),
+  pcbRouteHints: import_zod24.z.array(import_soup13.route_hint_point).optional()
 });
-var traceProps = import_zod23.z.union([
+var traceProps = import_zod24.z.union([
   baseTraceProps.extend({
-    path: import_zod23.z.array(portRef)
+    path: import_zod24.z.array(portRef)
   }),
   baseTraceProps.extend({
     from: portRef,
@@ -501,16 +535,16 @@ var traceProps = import_zod23.z.union([
 ]);
 
 // lib/components/footprint.ts
-var import_soup13 = require("@tscircuit/soup");
-var import_zod24 = require("zod");
-var footprintProps = import_zod24.z.object({
-  originalLayer: import_soup13.layer_ref.default("top").optional()
+var import_soup14 = require("@tscircuit/soup");
+var import_zod25 = require("zod");
+var footprintProps = import_zod25.z.object({
+  originalLayer: import_soup14.layer_ref.default("top").optional()
 });
 expectTypesMatch(true);
 
 // lib/components/battery.ts
-var import_zod25 = require("zod");
-var capacity = import_zod25.z.number().or(import_zod25.z.string().endsWith("mAh")).transform((v) => {
+var import_zod26 = require("zod");
+var capacity = import_zod26.z.number().or(import_zod26.z.string().endsWith("mAh")).transform((v) => {
   if (typeof v === "string") {
     const valString = v.replace("mAh", "");
     const num = Number.parseFloat(valString);
@@ -529,152 +563,134 @@ expectTypesMatch(true);
 
 // lib/index.ts
 var inductorProps = commonComponentProps.extend({
-  inductance: import_soup14.inductance
+  inductance: import_soup15.inductance
 });
 var inductorPins = lrPins;
 var diodeProps = commonComponentProps.extend({});
 var diodePins = lrPolarPins;
 var ledProps = commonComponentProps.extend({
-  color: import_zod26.z.string().optional()
+  color: import_zod27.z.string().optional()
 });
 var ledPins = lrPolarPins;
 var switchProps = commonComponentProps.extend({
-  ftype: import_zod26.z.literal("switch"),
-  switchType: import_zod26.z.enum(["spst"]).default("spst"),
-  isNormallyClosed: import_zod26.z.boolean().default(false)
+  ftype: import_zod27.z.literal("switch"),
+  switchType: import_zod27.z.enum(["spst"]).default("spst"),
+  isNormallyClosed: import_zod27.z.boolean().default(false)
 });
-var distanceOrMultiplier2 = import_soup14.distance.or(import_zod26.z.enum(["2x", "3x", "4x"]));
+var distanceOrMultiplier2 = import_soup15.distance.or(import_zod27.z.enum(["2x", "3x", "4x"]));
 var viaProps = commonLayoutProps.extend({
-  fromLayer: import_soup14.layer_ref,
-  toLayer: import_soup14.layer_ref,
-  holeDiameter: import_soup14.distance,
-  outerDiameter: import_soup14.distance
+  fromLayer: import_soup15.layer_ref,
+  toLayer: import_soup15.layer_ref,
+  holeDiameter: import_soup15.distance,
+  outerDiameter: import_soup15.distance
 });
 var netAliasProps = commonLayoutProps.extend({
-  net: import_zod26.z.string().optional()
+  net: import_zod27.z.string().optional()
 });
-var platedHoleProps = import_zod26.z.union([
-  pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
-    name: import_zod26.z.string().optional(),
-    shape: import_zod26.z.literal("circle"),
-    holeDiameter: import_soup14.distance,
-    outerDiameter: import_soup14.distance,
-    portHints: portHints.optional()
-  }),
-  pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
-    name: import_zod26.z.string().optional(),
-    shape: import_zod26.z.literal("oval"),
-    outerWidth: import_soup14.distance,
-    outerHeight: import_soup14.distance,
-    innerWidth: import_soup14.distance,
-    innerHeight: import_soup14.distance,
-    portHints: portHints.optional()
-  })
-]);
-var pcbKeepoutProps = import_zod26.z.union([
+var pcbKeepoutProps = import_zod27.z.union([
   pcbLayoutProps.omit({ pcbRotation: true }).extend({
-    shape: import_zod26.z.literal("circle"),
-    radius: import_soup14.distance
+    shape: import_zod27.z.literal("circle"),
+    radius: import_soup15.distance
   }),
   pcbLayoutProps.extend({
-    shape: import_zod26.z.literal("rect"),
-    width: import_soup14.distance,
-    height: import_soup14.distance
+    shape: import_zod27.z.literal("rect"),
+    width: import_soup15.distance,
+    height: import_soup15.distance
   })
 ]);
-var schematicBoxProps = import_zod26.z.object({
-  schX: import_soup14.distance,
-  schY: import_soup14.distance,
-  width: import_soup14.distance,
-  height: import_soup14.distance
-});
-var schematicTextProps = import_zod26.z.object({
-  schX: import_soup14.distance,
-  schY: import_soup14.distance,
-  text: import_zod26.z.string()
-});
-var schematicLineProps = import_zod26.z.object({
-  x1: import_soup14.distance,
-  y1: import_soup14.distance,
-  x2: import_soup14.distance,
-  y2: import_soup14.distance
-});
-var schematicPathProps = import_zod26.z.object({
-  points: import_zod26.z.array(import_soup14.point),
-  isFilled: import_zod26.z.boolean().optional().default(false),
-  fillColor: import_zod26.z.enum(["red", "blue"]).optional()
+var schematicBoxProps = import_zod27.z.object({
+  schX: import_soup15.distance,
+  schY: import_soup15.distance,
+  width: import_soup15.distance,
+  height: import_soup15.distance
+});
+var schematicTextProps = import_zod27.z.object({
+  schX: import_soup15.distance,
+  schY: import_soup15.distance,
+  text: import_zod27.z.string()
+});
+var schematicLineProps = import_zod27.z.object({
+  x1: import_soup15.distance,
+  y1: import_soup15.distance,
+  x2: import_soup15.distance,
+  y2: import_soup15.distance
+});
+var schematicPathProps = import_zod27.z.object({
+  points: import_zod27.z.array(import_soup15.point),
+  isFilled: import_zod27.z.boolean().optional().default(false),
+  fillColor: import_zod27.z.enum(["red", "blue"]).optional()
 });
 var componentProps = commonComponentProps;
 var powerSourceProps = commonComponentProps.extend({
-  voltage: import_soup14.voltage
+  voltage: import_soup15.voltage
 });
 var portProps = commonLayoutProps.extend({
-  name: import_zod26.z.string(),
-  pinNumber: import_zod26.z.number().optional(),
-  aliases: import_zod26.z.array(import_zod26.z.string()).optional(),
+  name: import_zod27.z.string(),
+  pinNumber: import_zod27.z.number().optional(),
+  aliases: import_zod27.z.array(import_zod27.z.string()).optional(),
   direction
 });
 var silkscreenTextProps = pcbLayoutProps.extend({
-  text: import_zod26.z.string(),
-  anchorAlignment: import_zod26.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
-  font: import_zod26.z.enum(["tscircuit2024"]).optional(),
-  fontSize: import_soup14.length.optional()
+  text: import_zod27.z.string(),
+  anchorAlignment: import_zod27.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  font: import_zod27.z.enum(["tscircuit2024"]).optional(),
+  fontSize: import_soup15.length.optional()
 });
 var silkscreenPathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  route: import_zod26.z.array(import_soup14.route_hint_point),
-  strokeWidth: import_soup14.length.optional()
+  route: import_zod27.z.array(import_soup15.route_hint_point),
+  strokeWidth: import_soup15.length.optional()
 });
 var silkscreenLineProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  strokeWidth: import_soup14.distance,
-  x1: import_soup14.distance,
-  y1: import_soup14.distance,
-  x2: import_soup14.distance,
-  y2: import_soup14.distance
+  strokeWidth: import_soup15.distance,
+  x1: import_soup15.distance,
+  y1: import_soup15.distance,
+  x2: import_soup15.distance,
+  y2: import_soup15.distance
 });
 var silkscreenRectProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  isFilled: import_zod26.z.boolean().optional(),
-  isOutline: import_zod26.z.boolean().optional(),
-  strokeWidth: import_soup14.distance.optional(),
-  width: import_soup14.distance,
-  height: import_soup14.distance
+  isFilled: import_zod27.z.boolean().optional(),
+  isOutline: import_zod27.z.boolean().optional(),
+  strokeWidth: import_soup15.distance.optional(),
+  width: import_soup15.distance,
+  height: import_soup15.distance
 });
 var silkscreenCircleProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  isFilled: import_zod26.z.boolean().optional(),
-  isOutline: import_zod26.z.boolean().optional(),
-  strokeWidth: import_soup14.distance.optional(),
-  radius: import_soup14.distance
-});
-var routeHintPointProps = import_zod26.z.object({
-  x: import_soup14.distance,
-  y: import_soup14.distance,
-  via: import_zod26.z.boolean().optional(),
-  toLayer: import_soup14.layer_ref.optional()
-});
-var traceHintProps = import_zod26.z.object({
-  for: import_zod26.z.string().optional().describe(
+  isFilled: import_zod27.z.boolean().optional(),
+  isOutline: import_zod27.z.boolean().optional(),
+  strokeWidth: import_soup15.distance.optional(),
+  radius: import_soup15.distance
+});
+var routeHintPointProps = import_zod27.z.object({
+  x: import_soup15.distance,
+  y: import_soup15.distance,
+  via: import_zod27.z.boolean().optional(),
+  toLayer: import_soup15.layer_ref.optional()
+});
+var traceHintProps = import_zod27.z.object({
+  for: import_zod27.z.string().optional().describe(
     "Selector for the port you're targeting, not required if you're inside a trace"
   ),
-  order: import_zod26.z.number().optional(),
-  offset: import_soup14.route_hint_point.or(routeHintPointProps).optional(),
-  offsets: import_zod26.z.array(import_soup14.route_hint_point).or(import_zod26.z.array(routeHintPointProps)).optional(),
-  traceWidth: import_zod26.z.number().optional()
+  order: import_zod27.z.number().optional(),
+  offset: import_soup15.route_hint_point.or(routeHintPointProps).optional(),
+  offsets: import_zod27.z.array(import_soup15.route_hint_point).or(import_zod27.z.array(routeHintPointProps)).optional(),
+  traceWidth: import_zod27.z.number().optional()
 });
-var pcbTraceProps = import_zod26.z.object({
-  layer: import_zod26.z.string().optional(),
-  thickness: import_soup14.distance.optional(),
-  route: import_zod26.z.array(import_soup14.route_hint_point)
+var pcbTraceProps = import_zod27.z.object({
+  layer: import_zod27.z.string().optional(),
+  thickness: import_soup15.distance.optional(),
+  route: import_zod27.z.array(import_soup15.route_hint_point)
 });
 var fabricationNoteTextProps = pcbLayoutProps.extend({
-  text: import_zod26.z.string(),
-  anchorAlignment: import_zod26.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
-  font: import_zod26.z.enum(["tscircuit2024"]).optional(),
-  fontSize: import_soup14.length.optional(),
-  color: import_zod26.z.string().optional()
+  text: import_zod27.z.string(),
+  anchorAlignment: import_zod27.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  font: import_zod27.z.enum(["tscircuit2024"]).optional(),
+  fontSize: import_soup15.length.optional(),
+  color: import_zod27.z.string().optional()
 });
 var fabricationNotePathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  route: import_zod26.z.array(import_soup14.route_hint_point),
-  strokeWidth: import_soup14.length.optional(),
-  color: import_zod26.z.string().optional()
+  route: import_zod27.z.array(import_soup15.route_hint_point),
+  strokeWidth: import_soup15.length.optional(),
+  color: import_zod27.z.string().optional()
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {