@tscircuit/footprinter 0.0.44 → 0.0.45

package/dist/index.cjs

@@ -2562,6 +2562,7 @@ var require_dist = __commonJS({
       all_layers: () => all_layers,
       any_soup_element: () => any_soup_element,
       any_source_component: () => any_source_component,
+      cad_component: () => cad_component,
       capacitance: () => capacitance,
       current: () => current,
       distance: () => distance2,
@@ -2571,6 +2572,8 @@ var require_dist = __commonJS({
       length: () => length6,
       pcb_board: () => pcb_board,
       pcb_component: () => pcb_component,
+      pcb_fabrication_note_path: () => pcb_fabrication_note_path,
+      pcb_fabrication_note_text: () => pcb_fabrication_note_text,
       pcb_hole: () => pcb_hole,
       pcb_placement_error: () => pcb_placement_error,
       pcb_plated_hole: () => pcb_plated_hole,
@@ -2578,8 +2581,11 @@ var require_dist = __commonJS({
       pcb_port_not_matched_error: () => pcb_port_not_matched_error,
       pcb_route_hint: () => pcb_route_hint,
       pcb_route_hints: () => pcb_route_hints,
+      pcb_silkscreen_circle: () => pcb_silkscreen_circle,
       pcb_silkscreen_line: () => pcb_silkscreen_line,
+      pcb_silkscreen_oval: () => pcb_silkscreen_oval,
       pcb_silkscreen_path: () => pcb_silkscreen_path,
+      pcb_silkscreen_rect: () => pcb_silkscreen_rect,
       pcb_silkscreen_text: () => pcb_silkscreen_text,
       pcb_smtpad: () => pcb_smtpad,
       pcb_text: () => pcb_text,
@@ -2588,7 +2594,9 @@ var require_dist = __commonJS({
       pcb_trace_hint: () => pcb_trace_hint,
       pcb_via: () => pcb_via,
       point: () => point,
+      point3: () => point3,
       position: () => position,
+      position3: () => position3,
       resistance: () => resistance,
       rotation: () => rotation,
       route_hint_point: () => route_hint_point,
@@ -2722,13 +2730,20 @@ var require_dist = __commonJS({
     });
     var position = point;
     var import_zod32 = require("zod");
-    var size = import_zod32.z.object({
-      width: import_zod32.z.number(),
-      height: import_zod32.z.number()
+    var point3 = import_zod32.z.object({
+      x: distance2,
+      y: distance2,
+      z: distance2
     });
-    var import_zod62 = require("zod");
+    var position3 = point3;
     var import_zod42 = require("zod");
-    var supplier_name = import_zod42.z.enum([
+    var size = import_zod42.z.object({
+      width: import_zod42.z.number(),
+      height: import_zod42.z.number()
+    });
+    var import_zod72 = require("zod");
+    var import_zod52 = require("zod");
+    var supplier_name = import_zod52.z.enum([
       "jlcpcb",
       "macrofab",
       "pcbway",
@@ -2736,52 +2751,52 @@ var require_dist = __commonJS({
       "mouser",
       "lcsc"
     ]);
-    var import_zod52 = require("zod");
-    var source_component_base = import_zod52.z.object({
-      type: import_zod52.z.literal("source_component"),
-      ftype: import_zod52.z.string().optional(),
-      source_component_id: import_zod52.z.string(),
-      name: import_zod52.z.string(),
+    var import_zod62 = require("zod");
+    var source_component_base = import_zod62.z.object({
+      type: import_zod62.z.literal("source_component"),
+      ftype: import_zod62.z.string().optional(),
+      source_component_id: import_zod62.z.string(),
+      name: import_zod62.z.string(),
       // part_numbers: z.array(z.string()).optional(),
-      supplier_part_numbers: import_zod52.z.record(supplier_name, import_zod52.z.array(import_zod52.z.string())).optional()
+      supplier_part_numbers: import_zod62.z.record(supplier_name, import_zod62.z.array(import_zod62.z.string())).optional()
     });
     var source_simple_capacitor = source_component_base.extend({
-      ftype: import_zod62.z.literal("simple_capacitor"),
+      ftype: import_zod72.z.literal("simple_capacitor"),
       capacitance
     });
-    var import_zod72 = require("zod");
+    var import_zod82 = require("zod");
     var source_simple_resistor = source_component_base.extend({
-      ftype: import_zod72.z.literal("simple_resistor"),
+      ftype: import_zod82.z.literal("simple_resistor"),
       resistance
     });
-    var import_zod82 = require("zod");
+    var import_zod92 = require("zod");
     var source_simple_diode = source_component_base.extend({
-      ftype: import_zod82.z.literal("simple_diode")
+      ftype: import_zod92.z.literal("simple_diode")
     });
-    var import_zod92 = require("zod");
+    var import_zod102 = require("zod");
     var source_simple_ground = source_component_base.extend({
-      ftype: import_zod92.z.literal("simple_ground")
+      ftype: import_zod102.z.literal("simple_ground")
     });
-    var import_zod102 = require("zod");
+    var import_zod11 = require("zod");
     var source_simple_bug = source_component_base.extend({
-      ftype: import_zod102.z.literal("simple_bug")
+      ftype: import_zod11.z.literal("simple_bug")
     });
-    var import_zod11 = require("zod");
+    var import_zod12 = require("zod");
     var source_simple_inductor = source_component_base.extend({
-      ftype: import_zod11.z.literal("simple_inductor"),
+      ftype: import_zod12.z.literal("simple_inductor"),
       inductance
     });
-    var import_zod12 = require("zod");
+    var import_zod13 = require("zod");
     var source_led = source_simple_diode.extend({
-      ftype: import_zod12.z.literal("led")
+      ftype: import_zod13.z.literal("led")
     });
-    var import_zod13 = require("zod");
+    var import_zod14 = require("zod");
     var source_simple_power_source = source_component_base.extend({
-      ftype: import_zod13.z.literal("simple_power_source"),
+      ftype: import_zod14.z.literal("simple_power_source"),
       voltage
     });
-    var import_zod14 = require("zod");
-    var any_source_component = import_zod14.z.union([
+    var import_zod15 = require("zod");
+    var any_source_component = import_zod15.z.union([
       source_simple_resistor,
       source_simple_capacitor,
       source_simple_diode,
@@ -2790,160 +2805,162 @@ var require_dist = __commonJS({
       source_led,
       source_simple_power_source
     ]);
-    var import_zod15 = require("zod");
-    var source_port = import_zod15.z.object({
-      type: import_zod15.z.literal("source_port"),
-      pin_number: import_zod15.z.number().optional(),
-      port_hints: import_zod15.z.array(import_zod15.z.string()).optional(),
-      name: import_zod15.z.string(),
-      source_port_id: import_zod15.z.string(),
-      source_component_id: import_zod15.z.string()
-    });
     var import_zod16 = require("zod");
-    var source_trace = import_zod16.z.object({
-      type: import_zod16.z.literal("source_trace"),
-      source_trace_id: import_zod16.z.string(),
-      connected_source_port_ids: import_zod16.z.array(import_zod16.z.string()),
-      connected_source_net_ids: import_zod16.z.array(import_zod16.z.string())
+    var source_port = import_zod16.z.object({
+      type: import_zod16.z.literal("source_port"),
+      pin_number: import_zod16.z.number().optional(),
+      port_hints: import_zod16.z.array(import_zod16.z.string()).optional(),
+      name: import_zod16.z.string(),
+      source_port_id: import_zod16.z.string(),
+      source_component_id: import_zod16.z.string()
     });
     var import_zod17 = require("zod");
-    var source_group = import_zod17.z.object({
-      type: import_zod17.z.literal("source_group"),
-      source_group_id: import_zod17.z.string(),
-      name: import_zod17.z.string().optional()
+    var source_trace = import_zod17.z.object({
+      type: import_zod17.z.literal("source_trace"),
+      source_trace_id: import_zod17.z.string(),
+      connected_source_port_ids: import_zod17.z.array(import_zod17.z.string()),
+      connected_source_net_ids: import_zod17.z.array(import_zod17.z.string())
     });
     var import_zod18 = require("zod");
-    var source_net = import_zod18.z.object({
-      type: import_zod18.z.literal("source_net"),
-      source_net_id: import_zod18.z.string(),
-      name: import_zod18.z.string(),
-      member_source_group_ids: import_zod18.z.array(import_zod18.z.string()),
-      is_power: import_zod18.z.boolean().optional(),
-      is_ground: import_zod18.z.boolean().optional(),
-      is_digital_signal: import_zod18.z.boolean().optional(),
-      is_analog_signal: import_zod18.z.boolean().optional()
+    var source_group = import_zod18.z.object({
+      type: import_zod18.z.literal("source_group"),
+      source_group_id: import_zod18.z.string(),
+      name: import_zod18.z.string().optional()
     });
     var import_zod19 = require("zod");
-    var schematic_box = import_zod19.z.object({
-      type: import_zod19.z.literal("schematic_box"),
-      schematic_component_id: import_zod19.z.string(),
+    var source_net = import_zod19.z.object({
+      type: import_zod19.z.literal("source_net"),
+      source_net_id: import_zod19.z.string(),
+      name: import_zod19.z.string(),
+      member_source_group_ids: import_zod19.z.array(import_zod19.z.string()),
+      is_power: import_zod19.z.boolean().optional(),
+      is_ground: import_zod19.z.boolean().optional(),
+      is_digital_signal: import_zod19.z.boolean().optional(),
+      is_analog_signal: import_zod19.z.boolean().optional()
+    });
+    var import_zod20 = require("zod");
+    var schematic_box = import_zod20.z.object({
+      type: import_zod20.z.literal("schematic_box"),
+      schematic_component_id: import_zod20.z.string(),
       width: distance2,
       height: distance2,
       x: distance2,
       y: distance2
     }).describe("Draws a box on the schematic");
-    var import_zod20 = require("zod");
-    var schematic_path = import_zod20.z.object({
-      type: import_zod20.z.literal("schematic_path"),
-      schematic_component_id: import_zod20.z.string(),
-      fill_color: import_zod20.z.enum(["red", "blue"]).optional(),
-      is_filled: import_zod20.z.boolean().optional(),
-      points: import_zod20.z.array(point)
-    });
     var import_zod21 = require("zod");
-    var schematic_component = import_zod21.z.object({
-      type: import_zod21.z.literal("schematic_component"),
+    var schematic_path = import_zod21.z.object({
+      type: import_zod21.z.literal("schematic_path"),
+      schematic_component_id: import_zod21.z.string(),
+      fill_color: import_zod21.z.enum(["red", "blue"]).optional(),
+      is_filled: import_zod21.z.boolean().optional(),
+      points: import_zod21.z.array(point)
+    });
+    var import_zod222 = require("zod");
+    var schematic_component = import_zod222.z.object({
+      type: import_zod222.z.literal("schematic_component"),
       rotation: rotation.default(0),
       size,
       center: point,
-      source_component_id: import_zod21.z.string(),
-      schematic_component_id: import_zod21.z.string(),
-      port_arrangement: import_zod21.z.union([
-        import_zod21.z.object({
-          left_size: import_zod21.z.number(),
-          right_size: import_zod21.z.number(),
-          top_size: import_zod21.z.number().optional(),
-          bottom_size: import_zod21.z.number().optional()
+      source_component_id: import_zod222.z.string(),
+      schematic_component_id: import_zod222.z.string(),
+      pin_spacing: length6.optional(),
+      box_width: length6.optional(),
+      port_arrangement: import_zod222.z.union([
+        import_zod222.z.object({
+          left_size: import_zod222.z.number(),
+          right_size: import_zod222.z.number(),
+          top_size: import_zod222.z.number().optional(),
+          bottom_size: import_zod222.z.number().optional()
         }),
-        import_zod21.z.object({
-          left_side: import_zod21.z.object({
-            pins: import_zod21.z.array(import_zod21.z.number()),
-            direction: import_zod21.z.enum(["top-to-bottom", "bottom-to-top"]).optional()
+        import_zod222.z.object({
+          left_side: import_zod222.z.object({
+            pins: import_zod222.z.array(import_zod222.z.number()),
+            direction: import_zod222.z.enum(["top-to-bottom", "bottom-to-top"]).optional()
           }).optional(),
-          right_side: import_zod21.z.object({
-            pins: import_zod21.z.array(import_zod21.z.number()),
-            direction: import_zod21.z.enum(["top-to-bottom", "bottom-to-top"]).optional()
+          right_side: import_zod222.z.object({
+            pins: import_zod222.z.array(import_zod222.z.number()),
+            direction: import_zod222.z.enum(["top-to-bottom", "bottom-to-top"]).optional()
           }).optional(),
-          top_side: import_zod21.z.object({
-            pins: import_zod21.z.array(import_zod21.z.number()),
-            direction: import_zod21.z.enum(["left-to-right", "right-to-left"]).optional()
+          top_side: import_zod222.z.object({
+            pins: import_zod222.z.array(import_zod222.z.number()),
+            direction: import_zod222.z.enum(["left-to-right", "right-to-left"]).optional()
           }).optional(),
-          bottom_side: import_zod21.z.object({
-            pins: import_zod21.z.array(import_zod21.z.number()),
-            direction: import_zod21.z.enum(["left-to-right", "right-to-left"]).optional()
+          bottom_side: import_zod222.z.object({
+            pins: import_zod222.z.array(import_zod222.z.number()),
+            direction: import_zod222.z.enum(["left-to-right", "right-to-left"]).optional()
           }).optional()
         })
       ]).optional(),
-      port_labels: import_zod21.z.record(import_zod21.z.string()).optional()
+      port_labels: import_zod222.z.record(import_zod222.z.string()).optional()
     });
-    var import_zod222 = require("zod");
-    var schematic_line = import_zod222.z.object({
-      type: import_zod222.z.literal("schematic_line"),
-      schematic_component_id: import_zod222.z.string(),
+    var import_zod23 = require("zod");
+    var schematic_line = import_zod23.z.object({
+      type: import_zod23.z.literal("schematic_line"),
+      schematic_component_id: import_zod23.z.string(),
       x1: distance2,
       x2: distance2,
       y1: distance2,
       y2: distance2
     });
-    var import_zod23 = require("zod");
-    var schematic_trace = import_zod23.z.object({
-      type: import_zod23.z.literal("schematic_trace"),
-      schematic_trace_id: import_zod23.z.string(),
-      source_trace_id: import_zod23.z.string(),
-      edges: import_zod23.z.array(
-        import_zod23.z.object({
-          from: import_zod23.z.object({
-            x: import_zod23.z.number(),
-            y: import_zod23.z.number()
+    var import_zod24 = require("zod");
+    var schematic_trace = import_zod24.z.object({
+      type: import_zod24.z.literal("schematic_trace"),
+      schematic_trace_id: import_zod24.z.string(),
+      source_trace_id: import_zod24.z.string(),
+      edges: import_zod24.z.array(
+        import_zod24.z.object({
+          from: import_zod24.z.object({
+            x: import_zod24.z.number(),
+            y: import_zod24.z.number()
           }),
-          to: import_zod23.z.object({
-            x: import_zod23.z.number(),
-            y: import_zod23.z.number()
+          to: import_zod24.z.object({
+            x: import_zod24.z.number(),
+            y: import_zod24.z.number()
           }),
-          from_schematic_port_id: import_zod23.z.string().optional(),
-          to_schematic_port_id: import_zod23.z.string().optional()
+          from_schematic_port_id: import_zod24.z.string().optional(),
+          to_schematic_port_id: import_zod24.z.string().optional()
         })
       )
     });
-    var import_zod24 = require("zod");
-    var schematic_text = import_zod24.z.object({
-      type: import_zod24.z.literal("schematic_text"),
-      schematic_component_id: import_zod24.z.string(),
-      schematic_text_id: import_zod24.z.string(),
-      text: import_zod24.z.string(),
-      position: import_zod24.z.object({
+    var import_zod25 = require("zod");
+    var schematic_text = import_zod25.z.object({
+      type: import_zod25.z.literal("schematic_text"),
+      schematic_component_id: import_zod25.z.string(),
+      schematic_text_id: import_zod25.z.string(),
+      text: import_zod25.z.string(),
+      position: import_zod25.z.object({
         x: distance2,
         y: distance2
       }),
-      rotation: import_zod24.z.number().default(0),
-      anchor: import_zod24.z.enum(["center", "left", "right", "top", "bottom"]).default("center")
+      rotation: import_zod25.z.number().default(0),
+      anchor: import_zod25.z.enum(["center", "left", "right", "top", "bottom"]).default("center")
     });
-    var import_zod25 = require("zod");
-    var schematic_port = import_zod25.z.object({
-      type: import_zod25.z.literal("schematic_port"),
-      schematic_port_id: import_zod25.z.string(),
-      source_port_id: import_zod25.z.string(),
-      schematic_component_id: import_zod25.z.string().optional(),
+    var import_zod26 = require("zod");
+    var schematic_port = import_zod26.z.object({
+      type: import_zod26.z.literal("schematic_port"),
+      schematic_port_id: import_zod26.z.string(),
+      source_port_id: import_zod26.z.string(),
+      schematic_component_id: import_zod26.z.string().optional(),
       center: point,
-      facing_direction: import_zod25.z.enum(["up", "down", "left", "right"]).optional()
+      facing_direction: import_zod26.z.enum(["up", "down", "left", "right"]).optional()
     }).describe("Defines a port on a schematic component");
-    var import_zod26 = require("zod");
-    var schematic_net_label = import_zod26.z.object({
-      type: import_zod26.z.literal("schematic_net_label"),
-      source_net_id: import_zod26.z.string(),
+    var import_zod27 = require("zod");
+    var schematic_net_label = import_zod27.z.object({
+      type: import_zod27.z.literal("schematic_net_label"),
+      source_net_id: import_zod27.z.string(),
       center: point,
-      anchor_side: import_zod26.z.enum(["top", "bottom", "left", "right"]),
-      text: import_zod26.z.string()
+      anchor_side: import_zod27.z.enum(["top", "bottom", "left", "right"]),
+      text: import_zod27.z.string()
     });
-    var import_zod27 = require("zod");
-    var schematic_error = import_zod27.z.object({
-      schematic_error_id: import_zod27.z.string(),
-      type: import_zod27.z.literal("schematic_error"),
+    var import_zod28 = require("zod");
+    var schematic_error = import_zod28.z.object({
+      schematic_error_id: import_zod28.z.string(),
+      type: import_zod28.z.literal("schematic_error"),
       // eventually each error type should be broken out into a dir of files
-      error_type: import_zod27.z.literal("schematic_port_not_found"),
-      message: import_zod27.z.string()
+      error_type: import_zod28.z.literal("schematic_port_not_found"),
+      message: import_zod28.z.string()
     }).describe("Defines a schematic error on the schematic");
-    var import_zod28 = require("zod");
+    var import_zod29 = require("zod");
     var all_layers = [
       "top",
       "bottom",
@@ -2954,9 +2971,9 @@ var require_dist = __commonJS({
       "inner5",
       "inner6"
     ];
-    var layer_string = import_zod28.z.enum(all_layers);
+    var layer_string = import_zod29.z.enum(all_layers);
     var layer_ref = layer_string.or(
-      import_zod28.z.object({
+      import_zod29.z.object({
         name: layer_string
       })
     ).transform((layer) => {
@@ -2965,149 +2982,176 @@ var require_dist = __commonJS({
       }
       return layer.name;
     });
-    var visible_layer = import_zod28.z.enum(["top", "bottom"]);
-    var import_zod29 = require("zod");
-    var pcb_route_hint = import_zod29.z.object({
+    var visible_layer = import_zod29.z.enum(["top", "bottom"]);
+    var import_zod30 = require("zod");
+    var pcb_route_hint = import_zod30.z.object({
       x: distance2,
       y: distance2,
-      via: import_zod29.z.boolean().optional(),
+      via: import_zod30.z.boolean().optional(),
       via_to_layer: layer_ref.optional()
     });
-    var pcb_route_hints = import_zod29.z.array(pcb_route_hint);
-    var import_zod30 = require("zod");
-    var route_hint_point = import_zod30.z.object({
+    var pcb_route_hints = import_zod30.z.array(pcb_route_hint);
+    var import_zod31 = require("zod");
+    var route_hint_point = import_zod31.z.object({
       x: distance2,
       y: distance2,
-      via: import_zod30.z.boolean().optional(),
+      via: import_zod31.z.boolean().optional(),
       to_layer: layer_ref.optional()
     });
-    var import_zod31 = require("zod");
-    var pcb_component = import_zod31.z.object({
-      type: import_zod31.z.literal("pcb_component"),
-      pcb_component_id: import_zod31.z.string(),
-      source_component_id: import_zod31.z.string(),
+    var import_zod322 = require("zod");
+    var pcb_component = import_zod322.z.object({
+      type: import_zod322.z.literal("pcb_component"),
+      pcb_component_id: import_zod322.z.string(),
+      source_component_id: import_zod322.z.string(),
       center: point,
       layer: layer_ref,
       rotation,
       width: length6,
       height: length6
     }).describe("Defines a component on the PCB");
-    var import_zod322 = require("zod");
-    var pcb_hole = import_zod322.z.object({
-      type: import_zod322.z.literal("pcb_hole"),
-      hole_diameter: import_zod322.z.number(),
-      x: distance2,
-      y: distance2
-    }).describe("Defines a hole on the PCB");
     var import_zod33 = require("zod");
-    var pcb_plated_hole = import_zod33.z.object({
-      type: import_zod33.z.literal("pcb_plated_hole"),
-      outer_diameter: import_zod33.z.number(),
+    var pcb_hole = import_zod33.z.object({
+      type: import_zod33.z.literal("pcb_hole"),
+      hole_shape: import_zod33.z.enum(["round", "square"]).default("round"),
       hole_diameter: import_zod33.z.number(),
       x: distance2,
-      y: distance2,
-      layers: import_zod33.z.array(layer_ref),
-      port_hints: import_zod33.z.array(import_zod33.z.string()).optional(),
-      pcb_component_id: import_zod33.z.string().optional(),
-      pcb_port_id: import_zod33.z.string().optional()
-    }).describe("Defines a plated hole on the PCB");
+      y: distance2
+    }).or(
+      import_zod33.z.object({
+        type: import_zod33.z.literal("pcb_hole"),
+        hole_shape: import_zod33.z.literal("oval"),
+        hole_width: import_zod33.z.number(),
+        hole_height: import_zod33.z.number(),
+        x: distance2,
+        y: distance2
+      })
+    ).describe("Defines a hole on the PCB");
     var import_zod34 = require("zod");
-    var pcb_port = import_zod34.z.object({
-      type: import_zod34.z.literal("pcb_port"),
-      pcb_port_id: import_zod34.z.string(),
-      source_port_id: import_zod34.z.string(),
-      pcb_component_id: import_zod34.z.string(),
+    var pcb_plated_hole = import_zod34.z.object({
+      type: import_zod34.z.literal("pcb_plated_hole"),
+      shape: import_zod34.z.literal("circle"),
+      outer_diameter: import_zod34.z.number(),
+      hole_diameter: import_zod34.z.number(),
       x: distance2,
       y: distance2,
-      layers: import_zod34.z.array(layer_ref)
-    }).describe("Defines a port on the PCB");
+      layers: import_zod34.z.array(layer_ref),
+      port_hints: import_zod34.z.array(import_zod34.z.string()).optional(),
+      pcb_component_id: import_zod34.z.string().optional(),
+      pcb_port_id: import_zod34.z.string().optional()
+    }).or(
+      import_zod34.z.object({
+        type: import_zod34.z.literal("pcb_plated_hole"),
+        shape: import_zod34.z.enum(["oval", "pill"]),
+        outer_width: import_zod34.z.number(),
+        outer_height: import_zod34.z.number(),
+        hole_width: import_zod34.z.number(),
+        hole_height: import_zod34.z.number(),
+        x: distance2,
+        y: distance2,
+        layers: import_zod34.z.array(layer_ref),
+        port_hints: import_zod34.z.array(import_zod34.z.string()).optional(),
+        pcb_component_id: import_zod34.z.string().optional(),
+        pcb_port_id: import_zod34.z.string().optional()
+      })
+    ).describe("Defines a plated hole on the PCB");
     var import_zod35 = require("zod");
-    var pcb_smtpad = import_zod35.z.union([
-      import_zod35.z.object({
-        pcb_smtpad_id: import_zod35.z.string(),
-        type: import_zod35.z.literal("pcb_smtpad"),
-        shape: import_zod35.z.literal("circle"),
+    var pcb_port = import_zod35.z.object({
+      type: import_zod35.z.literal("pcb_port"),
+      pcb_port_id: import_zod35.z.string(),
+      source_port_id: import_zod35.z.string(),
+      pcb_component_id: import_zod35.z.string(),
+      x: distance2,
+      y: distance2,
+      layers: import_zod35.z.array(layer_ref)
+    }).describe("Defines a port on the PCB");
+    var import_zod36 = require("zod");
+    var pcb_smtpad = import_zod36.z.union([
+      import_zod36.z.object({
+        pcb_smtpad_id: import_zod36.z.string(),
+        type: import_zod36.z.literal("pcb_smtpad"),
+        shape: import_zod36.z.literal("circle"),
         x: distance2,
         y: distance2,
-        radius: import_zod35.z.number(),
+        radius: import_zod36.z.number(),
         layer: layer_ref,
-        port_hints: import_zod35.z.array(import_zod35.z.string()).optional(),
-        pcb_component_id: import_zod35.z.string().optional(),
-        pcb_port_id: import_zod35.z.string().optional()
+        port_hints: import_zod36.z.array(import_zod36.z.string()).optional(),
+        pcb_component_id: import_zod36.z.string().optional(),
+        pcb_port_id: import_zod36.z.string().optional()
       }),
-      import_zod35.z.object({
-        pcb_smtpad_id: import_zod35.z.string(),
-        type: import_zod35.z.literal("pcb_smtpad"),
-        shape: import_zod35.z.literal("rect"),
+      import_zod36.z.object({
+        pcb_smtpad_id: import_zod36.z.string(),
+        type: import_zod36.z.literal("pcb_smtpad"),
+        shape: import_zod36.z.literal("rect"),
         x: distance2,
         y: distance2,
-        width: import_zod35.z.number(),
-        height: import_zod35.z.number(),
+        width: import_zod36.z.number(),
+        height: import_zod36.z.number(),
         layer: layer_ref,
-        port_hints: import_zod35.z.array(import_zod35.z.string()).optional(),
-        pcb_component_id: import_zod35.z.string().optional(),
-        pcb_port_id: import_zod35.z.string().optional()
+        port_hints: import_zod36.z.array(import_zod36.z.string()).optional(),
+        pcb_component_id: import_zod36.z.string().optional(),
+        pcb_port_id: import_zod36.z.string().optional()
       })
     ]).describe("Defines an SMT pad on the PCB");
-    var import_zod36 = require("zod");
-    var pcb_text = import_zod36.z.object({
-      type: import_zod36.z.literal("pcb_text"),
-      text: import_zod36.z.string(),
+    var import_zod37 = require("zod");
+    var pcb_text = import_zod37.z.object({
+      type: import_zod37.z.literal("pcb_text"),
+      text: import_zod37.z.string(),
       x: distance2,
       y: distance2,
-      align: import_zod36.z.enum(["bottom-left"]),
+      align: import_zod37.z.enum(["bottom-left"]),
       width: distance2,
       height: distance2,
-      lines: import_zod36.z.number()
+      lines: import_zod37.z.number()
     }).describe("Defines text on the PCB");
-    var import_zod37 = require("zod");
-    var pcb_trace = import_zod37.z.object({
-      type: import_zod37.z.literal("pcb_trace"),
-      source_trace_id: import_zod37.z.string(),
-      pcb_trace_id: import_zod37.z.string(),
-      route: import_zod37.z.array(
-        import_zod37.z.union([
-          import_zod37.z.object({
-            route_type: import_zod37.z.literal("wire"),
+    var import_zod38 = require("zod");
+    var pcb_trace = import_zod38.z.object({
+      type: import_zod38.z.literal("pcb_trace"),
+      source_trace_id: import_zod38.z.string().optional(),
+      pcb_component_id: import_zod38.z.string().optional(),
+      pcb_trace_id: import_zod38.z.string(),
+      route: import_zod38.z.array(
+        import_zod38.z.union([
+          import_zod38.z.object({
+            route_type: import_zod38.z.literal("wire"),
             x: distance2,
             y: distance2,
             width: distance2,
-            start_pcb_port_id: import_zod37.z.string().optional(),
-            end_pcb_port_id: import_zod37.z.string().optional(),
-            layer: import_zod37.z.string()
+            start_pcb_port_id: import_zod38.z.string().optional(),
+            end_pcb_port_id: import_zod38.z.string().optional(),
+            layer: import_zod38.z.string()
           }),
-          import_zod37.z.object({
-            route_type: import_zod37.z.literal("via"),
+          import_zod38.z.object({
+            route_type: import_zod38.z.literal("via"),
             x: distance2,
             y: distance2,
-            from_layer: import_zod37.z.string(),
-            to_layer: import_zod37.z.string()
+            from_layer: import_zod38.z.string(),
+            to_layer: import_zod38.z.string()
           })
         ])
       )
     });
-    var import_zod38 = require("zod");
-    var pcb_trace_error = import_zod38.z.object({
-      pcb_error_id: import_zod38.z.string(),
-      type: import_zod38.z.literal("pcb_error"),
-      error_type: import_zod38.z.literal("pcb_trace_error"),
-      message: import_zod38.z.string(),
-      pcb_trace_id: import_zod38.z.string(),
-      source_trace_id: import_zod38.z.string(),
-      pcb_component_ids: import_zod38.z.array(import_zod38.z.string()),
-      pcb_port_ids: import_zod38.z.array(import_zod38.z.string())
-    }).describe("Defines a trace error on the PCB");
     var import_zod39 = require("zod");
-    var pcb_port_not_matched_error = import_zod39.z.object({
+    var pcb_trace_error = import_zod39.z.object({
       pcb_error_id: import_zod39.z.string(),
       type: import_zod39.z.literal("pcb_error"),
-      error_type: import_zod39.z.literal("pcb_port_not_matched_error"),
+      error_type: import_zod39.z.literal("pcb_trace_error"),
       message: import_zod39.z.string(),
-      pcb_component_ids: import_zod39.z.array(import_zod39.z.string())
+      pcb_trace_id: import_zod39.z.string(),
+      source_trace_id: import_zod39.z.string(),
+      pcb_component_ids: import_zod39.z.array(import_zod39.z.string()),
+      pcb_port_ids: import_zod39.z.array(import_zod39.z.string())
     }).describe("Defines a trace error on the PCB");
     var import_zod40 = require("zod");
-    var pcb_via = import_zod40.z.object({
-      type: import_zod40.z.literal("pcb_via"),
+    var pcb_port_not_matched_error = import_zod40.z.object({
+      pcb_error_id: import_zod40.z.string(),
+      type: import_zod40.z.literal("pcb_error"),
+      error_type: import_zod40.z.literal("pcb_port_not_matched_error"),
+      message: import_zod40.z.string(),
+      pcb_component_ids: import_zod40.z.array(import_zod40.z.string())
+    }).describe("Defines a trace error on the PCB");
+    var import_zod41 = require("zod");
+    var pcb_via = import_zod41.z.object({
+      type: import_zod41.z.literal("pcb_via"),
       x: distance2,
       y: distance2,
       outer_diameter: distance2.default("0.6mm"),
@@ -3116,61 +3160,134 @@ var require_dist = __commonJS({
       from_layer: layer_ref.optional(),
       /** @deprecated */
       to_layer: layer_ref.optional(),
-      layers: import_zod40.z.array(layer_ref)
+      layers: import_zod41.z.array(layer_ref)
     }).describe("Defines a via on the PCB");
-    var import_zod41 = require("zod");
-    var pcb_board = import_zod41.z.object({
-      type: import_zod41.z.literal("pcb_board"),
+    var import_zod422 = require("zod");
+    var pcb_board = import_zod422.z.object({
+      type: import_zod422.z.literal("pcb_board"),
       width: length6,
       height: length6,
       center: point
     }).describe("Defines the board outline of the PCB");
-    var import_zod422 = require("zod");
-    var pcb_placement_error = import_zod422.z.object({
-      pcb_error_id: import_zod422.z.string(),
-      type: import_zod422.z.literal("pcb_error"),
-      error_type: import_zod422.z.literal("pcb_placement_error"),
-      message: import_zod422.z.string()
-    }).describe("Defines a placement error on the PCB");
     var import_zod43 = require("zod");
-    var pcb_trace_hint = import_zod43.z.object({
-      pcb_trace_hint_id: import_zod43.z.string(),
-      type: import_zod43.z.literal("pcb_trace_hint"),
-      pcb_port_id: import_zod43.z.string(),
-      pcb_component_id: import_zod43.z.string(),
-      route: import_zod43.z.array(route_hint_point)
-    }).describe("A hint that can be used to generate a PCB trace");
+    var pcb_placement_error = import_zod43.z.object({
+      pcb_error_id: import_zod43.z.string(),
+      type: import_zod43.z.literal("pcb_error"),
+      error_type: import_zod43.z.literal("pcb_placement_error"),
+      message: import_zod43.z.string()
+    }).describe("Defines a placement error on the PCB");
     var import_zod44 = require("zod");
-    var pcb_silkscreen_line = import_zod44.z.object({
-      type: import_zod44.z.literal("pcb_silkscreen_line"),
-      pcb_silkscreen_line_id: import_zod44.z.string(),
+    var pcb_trace_hint = import_zod44.z.object({
+      pcb_trace_hint_id: import_zod44.z.string(),
+      type: import_zod44.z.literal("pcb_trace_hint"),
+      pcb_port_id: import_zod44.z.string(),
       pcb_component_id: import_zod44.z.string(),
+      route: import_zod44.z.array(route_hint_point)
+    }).describe("A hint that can be used to generate a PCB trace");
+    var import_zod45 = require("zod");
+    var pcb_silkscreen_line = import_zod45.z.object({
+      type: import_zod45.z.literal("pcb_silkscreen_line"),
+      pcb_silkscreen_line_id: import_zod45.z.string(),
+      pcb_component_id: import_zod45.z.string(),
+      stroke_width: distance2.default("0.1mm"),
       x1: distance2,
       y1: distance2,
       x2: distance2,
       y2: distance2,
       layer: visible_layer
     }).describe("Defines a silkscreen line on the PCB");
-    var import_zod45 = require("zod");
-    var pcb_silkscreen_path = import_zod45.z.object({
-      type: import_zod45.z.literal("pcb_silkscreen_path"),
-      pcb_silkscreen_path_id: import_zod45.z.string(),
-      pcb_component_id: import_zod45.z.string(),
-      layer: visible_layer,
-      route: import_zod45.z.array(point)
-    }).describe("Defines a silkscreen path on the PCB");
     var import_zod46 = require("zod");
-    var pcb_silkscreen_text = import_zod46.z.object({
-      type: import_zod46.z.literal("pcb_silkscreen_text"),
-      font: import_zod46.z.literal("tscircuit2024").default("tscircuit2024"),
+    var pcb_silkscreen_path = import_zod46.z.object({
+      type: import_zod46.z.literal("pcb_silkscreen_path"),
+      pcb_silkscreen_path_id: import_zod46.z.string(),
       pcb_component_id: import_zod46.z.string(),
-      text: import_zod46.z.string(),
       layer: visible_layer,
-      pcbX: import_zod46.z.number(),
-      pcbY: import_zod46.z.number()
-    }).describe("Defines silkscreen text on the PCB");
+      route: import_zod46.z.array(point),
+      stroke_width: length6
+    }).describe("Defines a silkscreen path on the PCB");
     var import_zod47 = require("zod");
-    var any_soup_element = import_zod47.z.union([
+    var pcb_silkscreen_text = import_zod47.z.object({
+      type: import_zod47.z.literal("pcb_silkscreen_text"),
+      font: import_zod47.z.literal("tscircuit2024").default("tscircuit2024"),
+      font_size: distance2.default("0.2mm"),
+      pcb_component_id: import_zod47.z.string(),
+      text: import_zod47.z.string(),
+      layer: visible_layer,
+      anchor_position: point.default({ x: 0, y: 0 }),
+      anchor_alignment: import_zod47.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center")
+    }).describe("Defines silkscreen text on the PCB");
+    var import_zod48 = require("zod");
+    var pcb_silkscreen_rect = import_zod48.z.object({
+      type: import_zod48.z.literal("pcb_silkscreen_rect"),
+      pcb_silkscreen_rect_id: import_zod48.z.string(),
+      pcb_component_id: import_zod48.z.string(),
+      center: point,
+      width: distance2,
+      height: distance2,
+      layer: visible_layer
+    }).describe("Defines a silkscreen rect on the PCB");
+    var import_zod49 = require("zod");
+    var pcb_silkscreen_circle = import_zod49.z.object({
+      type: import_zod49.z.literal("pcb_silkscreen_circle"),
+      pcb_silkscreen_circle_id: import_zod49.z.string(),
+      pcb_component_id: import_zod49.z.string(),
+      center: point,
+      radius: distance2,
+      layer: visible_layer
+    }).describe("Defines a silkscreen circle on the PCB");
+    var import_zod50 = require("zod");
+    var pcb_silkscreen_oval = import_zod50.z.object({
+      type: import_zod50.z.literal("pcb_silkscreen_oval"),
+      pcb_silkscreen_oval_id: import_zod50.z.string(),
+      pcb_component_id: import_zod50.z.string(),
+      center: point,
+      radius_x: distance2,
+      radius_y: distance2,
+      layer: visible_layer
+    }).describe("Defines a silkscreen oval on the PCB");
+    var import_zod51 = require("zod");
+    var pcb_fabrication_note_text = import_zod51.z.object({
+      type: import_zod51.z.literal("pcb_fabrication_note_text"),
+      font: import_zod51.z.literal("tscircuit2024").default("tscircuit2024"),
+      font_size: distance2.default("1mm"),
+      pcb_component_id: import_zod51.z.string(),
+      text: import_zod51.z.string(),
+      layer: visible_layer,
+      anchor_position: point.default({ x: 0, y: 0 }),
+      anchor_alignment: import_zod51.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center")
+    }).describe(
+      "Defines a fabrication note in text on the PCB, useful for leaving notes for assemblers or fabricators"
+    );
+    var import_zod522 = require("zod");
+    var pcb_fabrication_note_path = import_zod522.z.object({
+      type: import_zod522.z.literal("pcb_fabrication_note_path"),
+      fabrication_note_path_id: import_zod522.z.string(),
+      pcb_component_id: import_zod522.z.string(),
+      layer: visible_layer,
+      route: import_zod522.z.array(point),
+      stroke_width: length6
+    }).describe(
+      "Defines a fabrication path on the PCB for fabricators or assemblers"
+    );
+    var import_zod53 = require("zod");
+    var cad_component = import_zod53.z.object({
+      type: import_zod53.z.literal("cad_component"),
+      cad_component_id: import_zod53.z.string(),
+      pcb_component_id: import_zod53.z.string(),
+      source_component_id: import_zod53.z.string(),
+      position: point3,
+      rotation: point3.optional(),
+      size: point3.optional(),
+      layer: layer_ref.optional(),
+      // These are all ways to generate/load the 3d model
+      footprinter_string: import_zod53.z.string().optional(),
+      model_obj_url: import_zod53.z.string().optional(),
+      model_stl_url: import_zod53.z.string().optional(),
+      model_3mf_url: import_zod53.z.string().optional(),
+      model_jscad: import_zod53.z.array(import_zod53.z.any()).optional()
+    }).describe("Defines a component on the PCB");
+    var import_zod54 = require("zod");
+    var any_soup_element = import_zod54.z.union([
       source_trace,
       source_port,
       any_source_component,
@@ -3195,9 +3312,14 @@ var require_dist = __commonJS({
       pcb_silkscreen_line,
       pcb_silkscreen_path,
       pcb_silkscreen_text,
+      pcb_silkscreen_rect,
+      pcb_silkscreen_circle,
+      pcb_silkscreen_oval,
       pcb_trace_error,
       pcb_placement_error,
       pcb_port_not_matched_error,
+      pcb_fabrication_note_path,
+      pcb_fabrication_note_text,
       schematic_box,
       schematic_text,
       schematic_line,
@@ -3206,7 +3328,8 @@ var require_dist = __commonJS({
       schematic_trace,
       schematic_path,
       schematic_error,
-      schematic_net_label
+      schematic_net_label,
+      cad_component
     ]);
   }
 });
@@ -3255,6 +3378,7 @@ var import_mm = require("@tscircuit/mm");
 var platedhole = (pn, x, y, id, od) => {
   return {
     type: "pcb_plated_hole",
+    shape: "circle",
     x,
     y,
     hole_diameter: (0, import_mm.mm)(id),