circuit-json 0.0.59 → 0.0.75

package/dist/index.js

@@ -31,12 +31,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   all_layers: () => all_layers,
+  any_circuit_element: () => any_circuit_element,
   any_soup_element: () => any_soup_element,
   any_source_component: () => any_source_component,
   cad_component: () => cad_component,
   capacitance: () => capacitance,
   current: () => current,
   distance: () => distance,
+  getZodPrefixedIdWithDefault: () => getZodPrefixedIdWithDefault,
   inductance: () => inductance,
   layer_ref: () => layer_ref,
   layer_string: () => layer_string,
@@ -46,6 +48,8 @@ __export(src_exports, {
   pcb_fabrication_note_path: () => pcb_fabrication_note_path,
   pcb_fabrication_note_text: () => pcb_fabrication_note_text,
   pcb_hole: () => pcb_hole,
+  pcb_hole_circle_or_square_shape: () => pcb_hole_circle_or_square_shape,
+  pcb_hole_oval_shape: () => pcb_hole_oval_shape,
   pcb_keepout: () => pcb_keepout,
   pcb_placement_error: () => pcb_placement_error,
   pcb_plated_hole: () => pcb_plated_hole,
@@ -64,6 +68,9 @@ __export(src_exports, {
   pcb_trace: () => pcb_trace,
   pcb_trace_error: () => pcb_trace_error,
   pcb_trace_hint: () => pcb_trace_hint,
+  pcb_trace_route_point: () => pcb_trace_route_point,
+  pcb_trace_route_point_via: () => pcb_trace_route_point_via,
+  pcb_trace_route_point_wire: () => pcb_trace_route_point_wire,
   pcb_via: () => pcb_via,
   point: () => point,
   point3: () => point3,
@@ -78,6 +85,7 @@ __export(src_exports, {
   schematic_line: () => schematic_line,
   schematic_net_label: () => schematic_net_label,
   schematic_path: () => schematic_path,
+  schematic_pin_styles: () => schematic_pin_styles,
   schematic_port: () => schematic_port,
   schematic_text: () => schematic_text,
   schematic_trace: () => schematic_trace,
@@ -199,7 +207,17 @@ var length = import_zod.z.string().or(import_zod.z.number()).transform((v) => pa
 var distance = length;
 var current = import_zod.z.string().or(import_zod.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
 var time = import_zod.z.string().or(import_zod.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
-var rotation = import_zod.z.string().or(import_zod.z.number()).transform((v) => parseAndConvertSiUnit(v).value);
+var rotation = import_zod.z.string().or(import_zod.z.number()).transform((arg) => {
+  if (typeof arg === "number")
+    return arg;
+  if (arg.endsWith("deg")) {
+    return Number.parseFloat(arg.split("deg")[0]);
+  }
+  if (arg.endsWith("rad")) {
+    return Number.parseFloat(arg.split("rad")[0]) * 180 / Math.PI;
+  }
+  return Number.parseFloat(arg);
+});
 
 // src/common/point.ts
 var import_zod2 = require("zod");
@@ -225,12 +243,19 @@ var size = import_zod4.z.object({
   height: import_zod4.z.number()
 });
 
+// src/common/getZodPrefixedIdWithDefault.ts
+var import_zod5 = require("zod");
+var import_nanoid = require("nanoid");
+var getZodPrefixedIdWithDefault = (prefix) => {
+  return import_zod5.z.string().optional().default(() => `${prefix}_${(0, import_nanoid.nanoid)(10)}`);
+};
+
 // src/source/source_simple_capacitor.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 
 // src/pcb/properties/supplier_name.ts
-var import_zod5 = require("zod");
-var supplier_name = import_zod5.z.enum([
+var import_zod6 = require("zod");
+var supplier_name = import_zod6.z.enum([
   "jlcpcb",
   "macrofab",
   "pcbway",
@@ -240,76 +265,76 @@ var supplier_name = import_zod5.z.enum([
 ]);
 
 // src/source/base/source_component_base.ts
-var import_zod6 = require("zod");
-var source_component_base = import_zod6.z.object({
-  type: import_zod6.z.literal("source_component"),
-  ftype: import_zod6.z.string().optional(),
-  source_component_id: import_zod6.z.string(),
-  name: import_zod6.z.string(),
-  manufacturer_part_number: import_zod6.z.string().optional(),
-  supplier_part_numbers: import_zod6.z.record(supplier_name, import_zod6.z.array(import_zod6.z.string())).optional()
+var import_zod7 = require("zod");
+var source_component_base = import_zod7.z.object({
+  type: import_zod7.z.literal("source_component"),
+  ftype: import_zod7.z.string().optional(),
+  source_component_id: import_zod7.z.string(),
+  name: import_zod7.z.string(),
+  manufacturer_part_number: import_zod7.z.string().optional(),
+  supplier_part_numbers: import_zod7.z.record(supplier_name, import_zod7.z.array(import_zod7.z.string())).optional()
 });
 
 // src/source/source_simple_capacitor.ts
 var source_simple_capacitor = source_component_base.extend({
-  ftype: import_zod7.z.literal("simple_capacitor"),
+  ftype: import_zod8.z.literal("simple_capacitor"),
   capacitance
 });
 
 // src/source/source_simple_resistor.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 var source_simple_resistor = source_component_base.extend({
-  ftype: import_zod8.z.literal("simple_resistor"),
+  ftype: import_zod9.z.literal("simple_resistor"),
   resistance
 });
 
 // src/source/source_simple_diode.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 var source_simple_diode = source_component_base.extend({
-  ftype: import_zod9.z.literal("simple_diode")
+  ftype: import_zod10.z.literal("simple_diode")
 });
 
 // src/source/source_simple_ground.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var source_simple_ground = source_component_base.extend({
-  ftype: import_zod10.z.literal("simple_ground")
+  ftype: import_zod11.z.literal("simple_ground")
 });
 
 // src/source/source_simple_bug.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var source_simple_bug = source_component_base.extend({
-  ftype: import_zod11.z.literal("simple_bug")
+  ftype: import_zod12.z.literal("simple_bug")
 }).describe("@deprecated");
 
 // src/source/source_simple_chip.ts
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 var source_simple_chip = source_component_base.extend({
-  ftype: import_zod12.z.literal("simple_chip")
+  ftype: import_zod13.z.literal("simple_chip")
 });
 
 // src/source/source_simple_inductor.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 var source_simple_inductor = source_component_base.extend({
-  ftype: import_zod13.z.literal("simple_inductor"),
+  ftype: import_zod14.z.literal("simple_inductor"),
   inductance
 });
 
 // src/source/source_led.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 var source_led = source_simple_diode.extend({
-  ftype: import_zod14.z.literal("led")
+  ftype: import_zod15.z.literal("led")
 });
 
 // src/source/source_simple_power_source.ts
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 var source_simple_power_source = source_component_base.extend({
-  ftype: import_zod15.z.literal("simple_power_source"),
+  ftype: import_zod16.z.literal("simple_power_source"),
   voltage
 });
 
 // src/source/any_source_component.ts
-var import_zod16 = require("zod");
-var any_source_component = import_zod16.z.union([
+var import_zod17 = require("zod");
+var any_source_component = import_zod17.z.union([
   source_simple_resistor,
   source_simple_capacitor,
   source_simple_diode,
@@ -321,52 +346,52 @@ var any_source_component = import_zod16.z.union([
 ]);
 
 // src/source/source_port.ts
-var import_zod17 = require("zod");
-var source_port = import_zod17.z.object({
-  type: import_zod17.z.literal("source_port"),
-  pin_number: import_zod17.z.number().optional(),
-  port_hints: import_zod17.z.array(import_zod17.z.string()).optional(),
-  name: import_zod17.z.string(),
-  source_port_id: import_zod17.z.string(),
-  source_component_id: import_zod17.z.string()
+var import_zod18 = require("zod");
+var source_port = import_zod18.z.object({
+  type: import_zod18.z.literal("source_port"),
+  pin_number: import_zod18.z.number().optional(),
+  port_hints: import_zod18.z.array(import_zod18.z.string()).optional(),
+  name: import_zod18.z.string(),
+  source_port_id: import_zod18.z.string(),
+  source_component_id: import_zod18.z.string()
 });
 
 // src/source/source_trace.ts
-var import_zod18 = require("zod");
-var source_trace = import_zod18.z.object({
-  type: import_zod18.z.literal("source_trace"),
-  source_trace_id: import_zod18.z.string(),
-  connected_source_port_ids: import_zod18.z.array(import_zod18.z.string()),
-  connected_source_net_ids: import_zod18.z.array(import_zod18.z.string())
+var import_zod19 = require("zod");
+var source_trace = import_zod19.z.object({
+  type: import_zod19.z.literal("source_trace"),
+  source_trace_id: import_zod19.z.string(),
+  connected_source_port_ids: import_zod19.z.array(import_zod19.z.string()),
+  connected_source_net_ids: import_zod19.z.array(import_zod19.z.string())
 });
 
 // src/source/source_group.ts
-var import_zod19 = require("zod");
-var source_group = import_zod19.z.object({
-  type: import_zod19.z.literal("source_group"),
-  source_group_id: import_zod19.z.string(),
-  name: import_zod19.z.string().optional()
+var import_zod20 = require("zod");
+var source_group = import_zod20.z.object({
+  type: import_zod20.z.literal("source_group"),
+  source_group_id: import_zod20.z.string(),
+  name: import_zod20.z.string().optional()
 });
 
 // src/source/source_net.ts
-var import_zod20 = require("zod");
-var source_net = import_zod20.z.object({
-  type: import_zod20.z.literal("source_net"),
-  source_net_id: import_zod20.z.string(),
-  name: import_zod20.z.string(),
-  member_source_group_ids: import_zod20.z.array(import_zod20.z.string()),
-  is_power: import_zod20.z.boolean().optional(),
-  is_ground: import_zod20.z.boolean().optional(),
-  is_digital_signal: import_zod20.z.boolean().optional(),
-  is_analog_signal: import_zod20.z.boolean().optional(),
-  trace_width: import_zod20.z.number().optional()
+var import_zod21 = require("zod");
+var source_net = import_zod21.z.object({
+  type: import_zod21.z.literal("source_net"),
+  source_net_id: import_zod21.z.string(),
+  name: import_zod21.z.string(),
+  member_source_group_ids: import_zod21.z.array(import_zod21.z.string()),
+  is_power: import_zod21.z.boolean().optional(),
+  is_ground: import_zod21.z.boolean().optional(),
+  is_digital_signal: import_zod21.z.boolean().optional(),
+  is_analog_signal: import_zod21.z.boolean().optional(),
+  trace_width: import_zod21.z.number().optional()
 });
 
 // src/schematic/schematic_box.ts
-var import_zod21 = require("zod");
-var schematic_box = import_zod21.z.object({
-  type: import_zod21.z.literal("schematic_box"),
-  schematic_component_id: import_zod21.z.string(),
+var import_zod22 = require("zod");
+var schematic_box = import_zod22.z.object({
+  type: import_zod22.z.literal("schematic_box"),
+  schematic_component_id: import_zod22.z.string(),
   width: distance,
   height: distance,
   x: distance,
@@ -374,61 +399,70 @@ var schematic_box = import_zod21.z.object({
 }).describe("Draws a box on the schematic");
 
 // src/schematic/schematic_path.ts
-var import_zod22 = require("zod");
-var schematic_path = import_zod22.z.object({
-  type: import_zod22.z.literal("schematic_path"),
-  schematic_component_id: import_zod22.z.string(),
-  fill_color: import_zod22.z.enum(["red", "blue"]).optional(),
-  is_filled: import_zod22.z.boolean().optional(),
-  points: import_zod22.z.array(point)
+var import_zod23 = require("zod");
+var schematic_path = import_zod23.z.object({
+  type: import_zod23.z.literal("schematic_path"),
+  schematic_component_id: import_zod23.z.string(),
+  fill_color: import_zod23.z.enum(["red", "blue"]).optional(),
+  is_filled: import_zod23.z.boolean().optional(),
+  points: import_zod23.z.array(point)
 });
 
 // src/schematic/schematic_component.ts
-var import_zod23 = require("zod");
-var schematic_component = import_zod23.z.object({
-  type: import_zod23.z.literal("schematic_component"),
+var import_zod24 = require("zod");
+var schematic_pin_styles = import_zod24.z.record(
+  import_zod24.z.object({
+    left_margin: length.optional(),
+    right_margin: length.optional(),
+    top_margin: length.optional(),
+    bottom_margin: length.optional()
+  })
+);
+var schematic_component = import_zod24.z.object({
+  type: import_zod24.z.literal("schematic_component"),
   rotation: rotation.default(0),
   size,
   center: point,
-  source_component_id: import_zod23.z.string(),
-  schematic_component_id: import_zod23.z.string(),
+  source_component_id: import_zod24.z.string(),
+  schematic_component_id: import_zod24.z.string(),
   pin_spacing: length.optional(),
+  pin_styles: schematic_pin_styles.optional(),
   box_width: length.optional(),
-  symbol_name: import_zod23.z.string().optional(),
-  port_arrangement: import_zod23.z.union([
-    import_zod23.z.object({
-      left_size: import_zod23.z.number(),
-      right_size: import_zod23.z.number(),
-      top_size: import_zod23.z.number().optional(),
-      bottom_size: import_zod23.z.number().optional()
+  symbol_name: import_zod24.z.string().optional(),
+  port_arrangement: import_zod24.z.union([
+    import_zod24.z.object({
+      left_size: import_zod24.z.number(),
+      right_size: import_zod24.z.number(),
+      top_size: import_zod24.z.number().optional(),
+      bottom_size: import_zod24.z.number().optional()
     }),
-    import_zod23.z.object({
-      left_side: import_zod23.z.object({
-        pins: import_zod23.z.array(import_zod23.z.number()),
-        direction: import_zod23.z.enum(["top-to-bottom", "bottom-to-top"]).optional()
+    import_zod24.z.object({
+      left_side: import_zod24.z.object({
+        pins: import_zod24.z.array(import_zod24.z.number()),
+        direction: import_zod24.z.enum(["top-to-bottom", "bottom-to-top"]).optional()
       }).optional(),
-      right_side: import_zod23.z.object({
-        pins: import_zod23.z.array(import_zod23.z.number()),
-        direction: import_zod23.z.enum(["top-to-bottom", "bottom-to-top"]).optional()
+      right_side: import_zod24.z.object({
+        pins: import_zod24.z.array(import_zod24.z.number()),
+        direction: import_zod24.z.enum(["top-to-bottom", "bottom-to-top"]).optional()
       }).optional(),
-      top_side: import_zod23.z.object({
-        pins: import_zod23.z.array(import_zod23.z.number()),
-        direction: import_zod23.z.enum(["left-to-right", "right-to-left"]).optional()
+      top_side: import_zod24.z.object({
+        pins: import_zod24.z.array(import_zod24.z.number()),
+        direction: import_zod24.z.enum(["left-to-right", "right-to-left"]).optional()
       }).optional(),
-      bottom_side: import_zod23.z.object({
-        pins: import_zod23.z.array(import_zod23.z.number()),
-        direction: import_zod23.z.enum(["left-to-right", "right-to-left"]).optional()
+      bottom_side: import_zod24.z.object({
+        pins: import_zod24.z.array(import_zod24.z.number()),
+        direction: import_zod24.z.enum(["left-to-right", "right-to-left"]).optional()
       }).optional()
     })
   ]).optional(),
-  port_labels: import_zod23.z.record(import_zod23.z.string()).optional()
+  port_labels: import_zod24.z.record(import_zod24.z.string()).optional()
 });
 
 // src/schematic/schematic_line.ts
-var import_zod24 = require("zod");
-var schematic_line = import_zod24.z.object({
-  type: import_zod24.z.literal("schematic_line"),
-  schematic_component_id: import_zod24.z.string(),
+var import_zod25 = require("zod");
+var schematic_line = import_zod25.z.object({
+  type: import_zod25.z.literal("schematic_line"),
+  schematic_component_id: import_zod25.z.string(),
   x1: distance,
   x2: distance,
   y1: distance,
@@ -436,75 +470,75 @@ var schematic_line = import_zod24.z.object({
 });
 
 // src/schematic/schematic_trace.ts
-var import_zod25 = require("zod");
-var schematic_trace = import_zod25.z.object({
-  type: import_zod25.z.literal("schematic_trace"),
-  schematic_trace_id: import_zod25.z.string(),
-  source_trace_id: import_zod25.z.string(),
-  edges: import_zod25.z.array(
-    import_zod25.z.object({
-      from: import_zod25.z.object({
-        x: import_zod25.z.number(),
-        y: import_zod25.z.number()
+var import_zod26 = require("zod");
+var schematic_trace = import_zod26.z.object({
+  type: import_zod26.z.literal("schematic_trace"),
+  schematic_trace_id: import_zod26.z.string(),
+  source_trace_id: import_zod26.z.string(),
+  edges: import_zod26.z.array(
+    import_zod26.z.object({
+      from: import_zod26.z.object({
+        x: import_zod26.z.number(),
+        y: import_zod26.z.number()
       }),
-      to: import_zod25.z.object({
-        x: import_zod25.z.number(),
-        y: import_zod25.z.number()
+      to: import_zod26.z.object({
+        x: import_zod26.z.number(),
+        y: import_zod26.z.number()
       }),
-      from_schematic_port_id: import_zod25.z.string().optional(),
-      to_schematic_port_id: import_zod25.z.string().optional()
+      from_schematic_port_id: import_zod26.z.string().optional(),
+      to_schematic_port_id: import_zod26.z.string().optional()
     })
   )
 });
 
 // src/schematic/schematic_text.ts
-var import_zod26 = require("zod");
-var schematic_text = import_zod26.z.object({
-  type: import_zod26.z.literal("schematic_text"),
-  schematic_component_id: import_zod26.z.string(),
-  schematic_text_id: import_zod26.z.string(),
-  text: import_zod26.z.string(),
-  position: import_zod26.z.object({
+var import_zod27 = require("zod");
+var schematic_text = import_zod27.z.object({
+  type: import_zod27.z.literal("schematic_text"),
+  schematic_component_id: import_zod27.z.string(),
+  schematic_text_id: import_zod27.z.string(),
+  text: import_zod27.z.string(),
+  position: import_zod27.z.object({
     x: distance,
     y: distance
   }),
-  rotation: import_zod26.z.number().default(0),
-  anchor: import_zod26.z.enum(["center", "left", "right", "top", "bottom"]).default("center")
+  rotation: import_zod27.z.number().default(0),
+  anchor: import_zod27.z.enum(["center", "left", "right", "top", "bottom"]).default("center")
 });
 
 // src/schematic/schematic_port.ts
-var import_zod27 = require("zod");
-var schematic_port = import_zod27.z.object({
-  type: import_zod27.z.literal("schematic_port"),
-  schematic_port_id: import_zod27.z.string(),
-  source_port_id: import_zod27.z.string(),
-  schematic_component_id: import_zod27.z.string().optional(),
+var import_zod28 = require("zod");
+var schematic_port = import_zod28.z.object({
+  type: import_zod28.z.literal("schematic_port"),
+  schematic_port_id: import_zod28.z.string(),
+  source_port_id: import_zod28.z.string(),
+  schematic_component_id: import_zod28.z.string().optional(),
   center: point,
-  facing_direction: import_zod27.z.enum(["up", "down", "left", "right"]).optional()
+  facing_direction: import_zod28.z.enum(["up", "down", "left", "right"]).optional()
 }).describe("Defines a port on a schematic component");
 
 // src/schematic/schematic_net_label.ts
-var import_zod28 = require("zod");
-var schematic_net_label = import_zod28.z.object({
-  type: import_zod28.z.literal("schematic_net_label"),
-  source_net_id: import_zod28.z.string(),
+var import_zod29 = require("zod");
+var schematic_net_label = import_zod29.z.object({
+  type: import_zod29.z.literal("schematic_net_label"),
+  source_net_id: import_zod29.z.string(),
   center: point,
-  anchor_side: import_zod28.z.enum(["top", "bottom", "left", "right"]),
-  text: import_zod28.z.string()
+  anchor_side: import_zod29.z.enum(["top", "bottom", "left", "right"]),
+  text: import_zod29.z.string()
 });
 
 // src/schematic/schematic_error.ts
-var import_zod29 = require("zod");
-var schematic_error = import_zod29.z.object({
-  schematic_error_id: import_zod29.z.string(),
-  type: import_zod29.z.literal("schematic_error"),
+var import_zod30 = require("zod");
+var schematic_error = import_zod30.z.object({
+  schematic_error_id: import_zod30.z.string(),
+  type: import_zod30.z.literal("schematic_error"),
   // eventually each error type should be broken out into a dir of files
-  error_type: import_zod29.z.literal("schematic_port_not_found"),
-  message: import_zod29.z.string()
+  error_type: import_zod30.z.literal("schematic_port_not_found"),
+  message: import_zod30.z.string()
 }).describe("Defines a schematic error on the schematic");
 
 // src/pcb/properties/layer_ref.ts
-var import_zod30 = require("zod");
+var import_zod31 = require("zod");
 var all_layers = [
   "top",
   "bottom",
@@ -515,9 +549,9 @@ var all_layers = [
   "inner5",
   "inner6"
 ];
-var layer_string = import_zod30.z.enum(all_layers);
+var layer_string = import_zod31.z.enum(all_layers);
 var layer_ref = layer_string.or(
-  import_zod30.z.object({
+  import_zod31.z.object({
     name: layer_string
   })
 ).transform((layer) => {
@@ -526,204 +560,258 @@ var layer_ref = layer_string.or(
   }
   return layer.name;
 });
-var visible_layer = import_zod30.z.enum(["top", "bottom"]);
+var visible_layer = import_zod31.z.enum(["top", "bottom"]);
 
 // src/pcb/properties/pcb_route_hints.ts
-var import_zod31 = require("zod");
-var pcb_route_hint = import_zod31.z.object({
+var import_zod32 = require("zod");
+var pcb_route_hint = import_zod32.z.object({
   x: distance,
   y: distance,
-  via: import_zod31.z.boolean().optional(),
+  via: import_zod32.z.boolean().optional(),
   via_to_layer: layer_ref.optional()
 });
-var pcb_route_hints = import_zod31.z.array(pcb_route_hint);
+var pcb_route_hints = import_zod32.z.array(pcb_route_hint);
 
 // src/pcb/properties/route_hint_point.ts
-var import_zod32 = require("zod");
-var route_hint_point = import_zod32.z.object({
+var import_zod33 = require("zod");
+var route_hint_point = import_zod33.z.object({
   x: distance,
   y: distance,
-  via: import_zod32.z.boolean().optional(),
+  via: import_zod33.z.boolean().optional(),
   to_layer: layer_ref.optional(),
   trace_width: distance.optional()
 });
 
 // src/pcb/pcb_component.ts
-var import_zod33 = require("zod");
-var pcb_component = import_zod33.z.object({
-  type: import_zod33.z.literal("pcb_component"),
-  pcb_component_id: import_zod33.z.string(),
-  source_component_id: import_zod33.z.string(),
+var import_zod34 = require("zod");
+
+// src/utils/expect-types-match.ts
+var expectTypesMatch = (shouldBe) => {
+};
+
+// src/pcb/pcb_component.ts
+var pcb_component = import_zod34.z.object({
+  type: import_zod34.z.literal("pcb_component"),
+  pcb_component_id: getZodPrefixedIdWithDefault("pcb_component"),
+  source_component_id: import_zod34.z.string(),
   center: point,
   layer: layer_ref,
   rotation,
   width: length,
   height: length
 }).describe("Defines a component on the PCB");
+expectTypesMatch(true);
 
 // src/pcb/pcb_hole.ts
-var import_zod34 = require("zod");
-var pcb_hole = import_zod34.z.object({
-  type: import_zod34.z.literal("pcb_hole"),
-  hole_shape: import_zod34.z.enum(["round", "square"]).default("round"),
-  hole_diameter: import_zod34.z.number(),
+var import_zod35 = require("zod");
+var pcb_hole_circle_or_square = import_zod35.z.object({
+  type: import_zod35.z.literal("pcb_hole"),
+  pcb_hole_id: getZodPrefixedIdWithDefault("pcb_hole"),
+  hole_shape: import_zod35.z.enum(["circle", "square"]),
+  hole_diameter: import_zod35.z.number(),
   x: distance,
   y: distance
-}).or(
-  import_zod34.z.object({
-    type: import_zod34.z.literal("pcb_hole"),
-    hole_shape: import_zod34.z.literal("oval"),
-    hole_width: import_zod34.z.number(),
-    hole_height: import_zod34.z.number(),
-    x: distance,
-    y: distance
-  })
-).describe("Defines a hole on the PCB");
+});
+var pcb_hole_circle_or_square_shape = pcb_hole_circle_or_square.describe(
+  "Defines a circular or square hole on the PCB"
+);
+expectTypesMatch(true);
+var pcb_hole_oval = import_zod35.z.object({
+  type: import_zod35.z.literal("pcb_hole"),
+  pcb_hole_id: getZodPrefixedIdWithDefault("pcb_hole"),
+  hole_shape: import_zod35.z.literal("oval"),
+  hole_width: import_zod35.z.number(),
+  hole_height: import_zod35.z.number(),
+  x: distance,
+  y: distance
+});
+var pcb_hole_oval_shape = pcb_hole_oval.describe(
+  "Defines an oval hole on the PCB"
+);
+expectTypesMatch(true);
+var pcb_hole = pcb_hole_circle_or_square.or(pcb_hole_oval);
 
 // src/pcb/pcb_plated_hole.ts
-var import_zod35 = require("zod");
-var pcb_plated_hole = import_zod35.z.object({
-  type: import_zod35.z.literal("pcb_plated_hole"),
-  shape: import_zod35.z.literal("circle"),
-  outer_diameter: import_zod35.z.number(),
-  hole_diameter: import_zod35.z.number(),
+var import_zod36 = require("zod");
+var pcb_plated_hole_circle = import_zod36.z.object({
+  type: import_zod36.z.literal("pcb_plated_hole"),
+  shape: import_zod36.z.literal("circle"),
+  outer_diameter: import_zod36.z.number(),
+  hole_diameter: import_zod36.z.number(),
   x: distance,
   y: distance,
-  layers: import_zod35.z.array(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()
-}).or(
-  import_zod35.z.object({
-    type: import_zod35.z.literal("pcb_plated_hole"),
-    shape: import_zod35.z.enum(["oval", "pill"]),
-    outer_width: import_zod35.z.number(),
-    outer_height: import_zod35.z.number(),
-    hole_width: import_zod35.z.number(),
-    hole_height: import_zod35.z.number(),
-    x: distance,
-    y: distance,
-    layers: import_zod35.z.array(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()
-  })
-).describe("Defines a plated hole on the PCB");
+  layers: import_zod36.z.array(layer_ref),
+  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(),
+  pcb_plated_hole_id: getZodPrefixedIdWithDefault("pcb_plated_hole")
+});
+var pcb_plated_hole_oval = import_zod36.z.object({
+  type: import_zod36.z.literal("pcb_plated_hole"),
+  shape: import_zod36.z.enum(["oval", "pill"]),
+  outer_width: import_zod36.z.number(),
+  outer_height: import_zod36.z.number(),
+  hole_width: import_zod36.z.number(),
+  hole_height: import_zod36.z.number(),
+  x: distance,
+  y: distance,
+  layers: import_zod36.z.array(layer_ref),
+  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(),
+  pcb_plated_hole_id: getZodPrefixedIdWithDefault("pcb_plated_hole")
+});
+var pcb_plated_hole = import_zod36.z.union([
+  pcb_plated_hole_circle,
+  pcb_plated_hole_oval
+]);
+expectTypesMatch(
+  true
+);
+expectTypesMatch(true);
 
 // src/pcb/pcb_port.ts
-var import_zod36 = require("zod");
-var pcb_port = import_zod36.z.object({
-  type: import_zod36.z.literal("pcb_port"),
-  pcb_port_id: import_zod36.z.string(),
-  source_port_id: import_zod36.z.string(),
-  pcb_component_id: import_zod36.z.string(),
+var import_zod37 = require("zod");
+var pcb_port = import_zod37.z.object({
+  type: import_zod37.z.literal("pcb_port"),
+  pcb_port_id: getZodPrefixedIdWithDefault("pcb_port"),
+  source_port_id: import_zod37.z.string(),
+  pcb_component_id: import_zod37.z.string(),
   x: distance,
   y: distance,
-  layers: import_zod36.z.array(layer_ref)
+  layers: import_zod37.z.array(layer_ref)
 }).describe("Defines a port on the PCB");
+expectTypesMatch(true);
 
 // src/pcb/pcb_smtpad.ts
-var import_zod37 = require("zod");
-var pcb_smtpad = import_zod37.z.union([
-  import_zod37.z.object({
-    pcb_smtpad_id: import_zod37.z.string(),
-    type: import_zod37.z.literal("pcb_smtpad"),
-    shape: import_zod37.z.literal("circle"),
-    x: distance,
-    y: distance,
-    radius: import_zod37.z.number(),
-    layer: layer_ref,
-    port_hints: import_zod37.z.array(import_zod37.z.string()).optional(),
-    pcb_component_id: import_zod37.z.string().optional(),
-    pcb_port_id: import_zod37.z.string().optional()
-  }),
-  import_zod37.z.object({
-    pcb_smtpad_id: import_zod37.z.string(),
-    type: import_zod37.z.literal("pcb_smtpad"),
-    shape: import_zod37.z.literal("rect"),
-    x: distance,
-    y: distance,
-    width: import_zod37.z.number(),
-    height: import_zod37.z.number(),
-    layer: layer_ref,
-    port_hints: import_zod37.z.array(import_zod37.z.string()).optional(),
-    pcb_component_id: import_zod37.z.string().optional(),
-    pcb_port_id: import_zod37.z.string().optional()
-  })
-]).describe("Defines an SMT pad on the PCB");
-
-// src/pcb/pcb_text.ts
 var import_zod38 = require("zod");
-var pcb_text = import_zod38.z.object({
-  type: import_zod38.z.literal("pcb_text"),
-  text: import_zod38.z.string(),
+var pcb_smtpad_circle = import_zod38.z.object({
+  type: import_zod38.z.literal("pcb_smtpad"),
+  shape: import_zod38.z.literal("circle"),
+  pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
   x: distance,
   y: distance,
-  align: import_zod38.z.enum(["bottom-left"]),
-  width: distance,
-  height: distance,
-  lines: import_zod38.z.number()
+  radius: import_zod38.z.number(),
+  layer: layer_ref,
+  port_hints: import_zod38.z.array(import_zod38.z.string()).optional(),
+  pcb_component_id: import_zod38.z.string().optional(),
+  pcb_port_id: import_zod38.z.string().optional()
+});
+var pcb_smtpad_rect = import_zod38.z.object({
+  type: import_zod38.z.literal("pcb_smtpad"),
+  shape: import_zod38.z.literal("rect"),
+  pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
+  x: distance,
+  y: distance,
+  width: import_zod38.z.number(),
+  height: import_zod38.z.number(),
+  layer: layer_ref,
+  port_hints: import_zod38.z.array(import_zod38.z.string()).optional(),
+  pcb_component_id: import_zod38.z.string().optional(),
+  pcb_port_id: import_zod38.z.string().optional()
+});
+var pcb_smtpad = import_zod38.z.union([pcb_smtpad_circle, pcb_smtpad_rect]).describe("Defines an SMT pad on the PCB");
+expectTypesMatch(true);
+expectTypesMatch(true);
+
+// src/pcb/pcb_text.ts
+var import_zod39 = require("zod");
+var pcb_text = import_zod39.z.object({
+  type: import_zod39.z.literal("pcb_text"),
+  pcb_text_id: getZodPrefixedIdWithDefault("pcb_text"),
+  text: import_zod39.z.string(),
+  center: point,
+  layer: layer_ref,
+  width: length,
+  height: length,
+  lines: import_zod39.z.number(),
+  align: import_zod39.z.enum(["bottom-left"])
 }).describe("Defines text on the PCB");
+expectTypesMatch(true);
 
 // src/pcb/pcb_trace.ts
-var import_zod39 = require("zod");
-var pcb_trace = import_zod39.z.object({
-  type: import_zod39.z.literal("pcb_trace"),
-  source_trace_id: import_zod39.z.string().optional(),
-  pcb_component_id: import_zod39.z.string().optional(),
-  pcb_trace_id: import_zod39.z.string(),
-  route_thickness_mode: import_zod39.z.enum(["constant", "interpolated"]).default("interpolated"),
-  should_round_corners: import_zod39.z.boolean().optional(),
-  route: import_zod39.z.array(
-    import_zod39.z.union([
-      import_zod39.z.object({
-        route_type: import_zod39.z.literal("wire"),
+var import_zod40 = require("zod");
+var pcb_trace_route_point_wire = import_zod40.z.object({
+  route_type: import_zod40.z.literal("wire"),
+  x: distance,
+  y: distance,
+  width: distance,
+  start_pcb_port_id: import_zod40.z.string().optional(),
+  end_pcb_port_id: import_zod40.z.string().optional(),
+  layer: layer_ref
+});
+var pcb_trace_route_point_via = import_zod40.z.object({
+  route_type: import_zod40.z.literal("via"),
+  x: distance,
+  y: distance,
+  from_layer: import_zod40.z.string(),
+  to_layer: import_zod40.z.string()
+});
+var pcb_trace_route_point = import_zod40.z.union([
+  pcb_trace_route_point_wire,
+  pcb_trace_route_point_via
+]);
+var pcb_trace = import_zod40.z.object({
+  type: import_zod40.z.literal("pcb_trace"),
+  source_trace_id: import_zod40.z.string().optional(),
+  pcb_component_id: import_zod40.z.string().optional(),
+  pcb_trace_id: getZodPrefixedIdWithDefault("pcb_trace"),
+  route_thickness_mode: import_zod40.z.enum(["constant", "interpolated"]).default("constant").optional(),
+  should_round_corners: import_zod40.z.boolean().optional(),
+  route: import_zod40.z.array(
+    import_zod40.z.union([
+      import_zod40.z.object({
+        route_type: import_zod40.z.literal("wire"),
         x: distance,
         y: distance,
         width: distance,
-        start_pcb_port_id: import_zod39.z.string().optional(),
-        end_pcb_port_id: import_zod39.z.string().optional(),
-        layer: import_zod39.z.string()
+        start_pcb_port_id: import_zod40.z.string().optional(),
+        end_pcb_port_id: import_zod40.z.string().optional(),
+        layer: layer_ref
       }),
-      import_zod39.z.object({
-        route_type: import_zod39.z.literal("via"),
+      import_zod40.z.object({
+        route_type: import_zod40.z.literal("via"),
         x: distance,
         y: distance,
-        from_layer: import_zod39.z.string(),
-        to_layer: import_zod39.z.string()
+        from_layer: import_zod40.z.string(),
+        to_layer: import_zod40.z.string()
       })
     ])
   )
-});
+}).describe("Defines a trace on the PCB");
+expectTypesMatch(true);
+expectTypesMatch(true);
 
 // src/pcb/pcb_trace_error.ts
-var import_zod40 = require("zod");
-var pcb_trace_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_trace_error"),
-  message: import_zod40.z.string(),
+var import_zod41 = require("zod");
+var pcb_trace_error = import_zod41.z.object({
+  type: import_zod41.z.literal("pcb_trace_error"),
+  pcb_trace_error_id: getZodPrefixedIdWithDefault("pcb_trace_error"),
+  error_type: import_zod41.z.literal("pcb_trace_error"),
+  message: import_zod41.z.string(),
   center: point.optional(),
-  pcb_trace_id: import_zod40.z.string(),
-  source_trace_id: import_zod40.z.string(),
-  pcb_component_ids: import_zod40.z.array(import_zod40.z.string()),
-  pcb_port_ids: import_zod40.z.array(import_zod40.z.string())
+  pcb_trace_id: import_zod41.z.string(),
+  source_trace_id: import_zod41.z.string(),
+  pcb_component_ids: import_zod41.z.array(import_zod41.z.string()),
+  pcb_port_ids: import_zod41.z.array(import_zod41.z.string())
 }).describe("Defines a trace error on the PCB");
+expectTypesMatch(true);
 
 // src/pcb/pcb_port_not_matched_error.ts
-var import_zod41 = require("zod");
-var pcb_port_not_matched_error = import_zod41.z.object({
-  pcb_error_id: import_zod41.z.string(),
-  type: import_zod41.z.literal("pcb_error"),
-  error_type: import_zod41.z.literal("pcb_port_not_matched_error"),
-  message: import_zod41.z.string(),
-  pcb_component_ids: import_zod41.z.array(import_zod41.z.string())
-}).describe("Defines a trace error on the PCB");
+var import_zod42 = require("zod");
+var pcb_port_not_matched_error = import_zod42.z.object({
+  type: import_zod42.z.literal("pcb_port_not_matched_error"),
+  pcb_error_id: getZodPrefixedIdWithDefault("pcb_error"),
+  message: import_zod42.z.string(),
+  pcb_component_ids: import_zod42.z.array(import_zod42.z.string())
+}).describe("Defines a trace error on the PCB where a port is not matched");
+expectTypesMatch(true);
 
 // src/pcb/pcb_via.ts
-var import_zod42 = require("zod");
-var pcb_via = import_zod42.z.object({
-  type: import_zod42.z.literal("pcb_via"),
+var import_zod43 = require("zod");
+var pcb_via = import_zod43.z.object({
+  type: import_zod43.z.literal("pcb_via"),
+  pcb_via_id: getZodPrefixedIdWithDefault("pcb_via"),
   x: distance,
   y: distance,
   outer_diameter: distance.default("0.6mm"),
@@ -732,44 +820,48 @@ var pcb_via = import_zod42.z.object({
   from_layer: layer_ref.optional(),
   /** @deprecated */
   to_layer: layer_ref.optional(),
-  layers: import_zod42.z.array(layer_ref)
+  layers: import_zod43.z.array(layer_ref)
 }).describe("Defines a via on the PCB");
+expectTypesMatch(true);
 
 // src/pcb/pcb_board.ts
-var import_zod43 = require("zod");
-var pcb_board = import_zod43.z.object({
-  type: import_zod43.z.literal("pcb_board"),
-  pcb_board_id: import_zod43.z.string().default("pcb_board_0"),
+var import_zod44 = require("zod");
+var pcb_board = import_zod44.z.object({
+  type: import_zod44.z.literal("pcb_board"),
+  pcb_board_id: getZodPrefixedIdWithDefault("pcb_board"),
   width: length,
   height: length,
-  center: point
+  center: point,
+  outline: import_zod44.z.array(point).optional()
 }).describe("Defines the board outline of the PCB");
+expectTypesMatch(true);
 
 // src/pcb/pcb_placement_error.ts
-var import_zod44 = require("zod");
-var pcb_placement_error = import_zod44.z.object({
-  pcb_error_id: import_zod44.z.string(),
-  type: import_zod44.z.literal("pcb_error"),
-  error_type: import_zod44.z.literal("pcb_placement_error"),
-  message: import_zod44.z.string()
+var import_zod45 = require("zod");
+var pcb_placement_error = import_zod45.z.object({
+  type: import_zod45.z.literal("pcb_placement_error"),
+  pcb_placement_error_id: getZodPrefixedIdWithDefault("pcb_placement_error"),
+  message: import_zod45.z.string()
 }).describe("Defines a placement error on the PCB");
+expectTypesMatch(true);
 
 // src/pcb/pcb_trace_hint.ts
-var import_zod45 = require("zod");
-var pcb_trace_hint = import_zod45.z.object({
-  pcb_trace_hint_id: import_zod45.z.string(),
-  type: import_zod45.z.literal("pcb_trace_hint"),
-  pcb_port_id: import_zod45.z.string(),
-  pcb_component_id: import_zod45.z.string(),
-  route: import_zod45.z.array(route_hint_point.optional())
-}).describe("A hint that can be used to generate a PCB trace");
-
-// src/pcb/pcb_silkscreen_line.ts
 var import_zod46 = require("zod");
-var pcb_silkscreen_line = import_zod46.z.object({
-  type: import_zod46.z.literal("pcb_silkscreen_line"),
-  pcb_silkscreen_line_id: import_zod46.z.string(),
+var pcb_trace_hint = import_zod46.z.object({
+  type: import_zod46.z.literal("pcb_trace_hint"),
+  pcb_trace_hint_id: getZodPrefixedIdWithDefault("pcb_trace_hint"),
+  pcb_port_id: import_zod46.z.string(),
   pcb_component_id: import_zod46.z.string(),
+  route: import_zod46.z.array(route_hint_point)
+}).describe("A hint that can be used during generation of a PCB trace");
+expectTypesMatch(true);
+
+// src/pcb/pcb_silkscreen_line.ts
+var import_zod47 = require("zod");
+var pcb_silkscreen_line = import_zod47.z.object({
+  type: import_zod47.z.literal("pcb_silkscreen_line"),
+  pcb_silkscreen_line_id: getZodPrefixedIdWithDefault("pcb_silkscreen_line"),
+  pcb_component_id: import_zod47.z.string(),
   stroke_width: distance.default("0.1mm"),
   x1: distance,
   y1: distance,
@@ -777,141 +869,161 @@ var pcb_silkscreen_line = import_zod46.z.object({
   y2: distance,
   layer: visible_layer
 }).describe("Defines a silkscreen line on the PCB");
+expectTypesMatch(true);
 
 // src/pcb/pcb_silkscreen_path.ts
-var import_zod47 = require("zod");
-var pcb_silkscreen_path = import_zod47.z.object({
-  type: import_zod47.z.literal("pcb_silkscreen_path"),
-  pcb_silkscreen_path_id: import_zod47.z.string(),
-  pcb_component_id: import_zod47.z.string(),
+var import_zod48 = require("zod");
+var pcb_silkscreen_path = import_zod48.z.object({
+  type: import_zod48.z.literal("pcb_silkscreen_path"),
+  pcb_silkscreen_path_id: getZodPrefixedIdWithDefault("pcb_silkscreen_path"),
+  pcb_component_id: import_zod48.z.string(),
   layer: visible_layer,
-  route: import_zod47.z.array(point),
+  route: import_zod48.z.array(point),
   stroke_width: length
 }).describe("Defines a silkscreen path on the PCB");
+expectTypesMatch(true);
 
 // src/pcb/pcb_silkscreen_text.ts
-var import_zod48 = require("zod");
-var pcb_silkscreen_text = import_zod48.z.object({
-  type: import_zod48.z.literal("pcb_silkscreen_text"),
-  font: import_zod48.z.literal("tscircuit2024").default("tscircuit2024"),
+var import_zod49 = require("zod");
+var pcb_silkscreen_text = import_zod49.z.object({
+  type: import_zod49.z.literal("pcb_silkscreen_text"),
+  pcb_silkscreen_text_id: getZodPrefixedIdWithDefault("pcb_silkscreen_text"),
+  font: import_zod49.z.literal("tscircuit2024").default("tscircuit2024"),
   font_size: distance.default("0.2mm"),
-  pcb_component_id: import_zod48.z.string(),
-  text: import_zod48.z.string(),
-  layer: visible_layer,
+  pcb_component_id: import_zod49.z.string(),
+  text: import_zod49.z.string(),
+  layer: layer_ref,
   anchor_position: point.default({ x: 0, y: 0 }),
-  anchor_alignment: import_zod48.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center")
+  anchor_alignment: import_zod49.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center")
 }).describe("Defines silkscreen text on the PCB");
+expectTypesMatch(true);
 
 // src/pcb/pcb_silkscreen_rect.ts
-var import_zod49 = require("zod");
-var pcb_silkscreen_rect = import_zod49.z.object({
-  type: import_zod49.z.literal("pcb_silkscreen_rect"),
-  pcb_silkscreen_rect_id: import_zod49.z.string(),
-  pcb_component_id: import_zod49.z.string(),
+var import_zod50 = require("zod");
+var pcb_silkscreen_rect = import_zod50.z.object({
+  type: import_zod50.z.literal("pcb_silkscreen_rect"),
+  pcb_silkscreen_rect_id: getZodPrefixedIdWithDefault("pcb_silkscreen_rect"),
+  pcb_component_id: import_zod50.z.string(),
   center: point,
-  width: distance,
-  height: distance,
-  layer: visible_layer
+  width: length,
+  height: length,
+  layer: layer_ref
 }).describe("Defines a silkscreen rect on the PCB");
+expectTypesMatch(true);
 
 // src/pcb/pcb_silkscreen_circle.ts
-var import_zod50 = require("zod");
-var pcb_silkscreen_circle = import_zod50.z.object({
-  type: import_zod50.z.literal("pcb_silkscreen_circle"),
-  pcb_silkscreen_circle_id: import_zod50.z.string(),
-  pcb_component_id: import_zod50.z.string(),
+var import_zod51 = require("zod");
+var pcb_silkscreen_circle = import_zod51.z.object({
+  type: import_zod51.z.literal("pcb_silkscreen_circle"),
+  pcb_silkscreen_circle_id: getZodPrefixedIdWithDefault(
+    "pcb_silkscreen_circle"
+  ),
+  pcb_component_id: import_zod51.z.string(),
   center: point,
-  radius: distance,
+  radius: length,
   layer: visible_layer
 }).describe("Defines a silkscreen circle on the PCB");
+expectTypesMatch(true);
 
 // src/pcb/pcb_silkscreen_oval.ts
-var import_zod51 = require("zod");
-var pcb_silkscreen_oval = import_zod51.z.object({
-  type: import_zod51.z.literal("pcb_silkscreen_oval"),
-  pcb_silkscreen_oval_id: import_zod51.z.string(),
-  pcb_component_id: import_zod51.z.string(),
+var import_zod52 = require("zod");
+var pcb_silkscreen_oval = import_zod52.z.object({
+  type: import_zod52.z.literal("pcb_silkscreen_oval"),
+  pcb_silkscreen_oval_id: getZodPrefixedIdWithDefault("pcb_silkscreen_oval"),
+  pcb_component_id: import_zod52.z.string(),
   center: point,
   radius_x: distance,
   radius_y: distance,
   layer: visible_layer
 }).describe("Defines a silkscreen oval on the PCB");
+expectTypesMatch(true);
 
 // src/pcb/pcb_fabrication_note_text.ts
-var import_zod52 = require("zod");
-var pcb_fabrication_note_text = import_zod52.z.object({
-  type: import_zod52.z.literal("pcb_fabrication_note_text"),
-  font: import_zod52.z.literal("tscircuit2024").default("tscircuit2024"),
+var import_zod53 = require("zod");
+var pcb_fabrication_note_text = import_zod53.z.object({
+  type: import_zod53.z.literal("pcb_fabrication_note_text"),
+  pcb_fabrication_note_text_id: getZodPrefixedIdWithDefault(
+    "pcb_fabrication_note_text"
+  ),
+  font: import_zod53.z.literal("tscircuit2024").default("tscircuit2024"),
   font_size: distance.default("1mm"),
-  pcb_component_id: import_zod52.z.string(),
-  text: import_zod52.z.string(),
+  pcb_component_id: import_zod53.z.string(),
+  text: import_zod53.z.string(),
   layer: visible_layer,
   anchor_position: point.default({ x: 0, y: 0 }),
-  anchor_alignment: import_zod52.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center")
+  anchor_alignment: import_zod53.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  color: import_zod53.z.string().optional()
 }).describe(
   "Defines a fabrication note in text on the PCB, useful for leaving notes for assemblers or fabricators"
 );
+expectTypesMatch(true);
 
 // src/pcb/pcb_fabrication_note_path.ts
-var import_zod53 = require("zod");
-var pcb_fabrication_note_path = import_zod53.z.object({
-  type: import_zod53.z.literal("pcb_fabrication_note_path"),
-  fabrication_note_path_id: import_zod53.z.string(),
-  pcb_component_id: import_zod53.z.string(),
-  layer: visible_layer,
-  route: import_zod53.z.array(point),
-  stroke_width: length
+var import_zod54 = require("zod");
+var pcb_fabrication_note_path = import_zod54.z.object({
+  type: import_zod54.z.literal("pcb_fabrication_note_path"),
+  pcb_fabrication_note_path_id: getZodPrefixedIdWithDefault(
+    "pcb_fabrication_note_path"
+  ),
+  pcb_component_id: import_zod54.z.string(),
+  layer: layer_ref,
+  route: import_zod54.z.array(point),
+  stroke_width: length,
+  color: import_zod54.z.string().optional()
 }).describe(
   "Defines a fabrication path on the PCB for fabricators or assemblers"
 );
+expectTypesMatch(true);
 
 // src/pcb/pcb_keepout.ts
-var import_zod54 = require("zod");
-var pcb_keepout = import_zod54.z.object({
-  type: import_zod54.z.literal("pcb_keepout"),
-  pcb_keepout_id: import_zod54.z.string(),
-  layer: import_zod54.z.array(import_zod54.z.string()).optional(),
+var import_zod55 = require("zod");
+var pcb_keepout = import_zod55.z.object({
+  type: import_zod55.z.literal("pcb_keepout"),
+  shape: import_zod55.z.literal("rect"),
+  center: point,
+  width: distance,
+  height: distance,
+  pcb_keepout_id: import_zod55.z.string(),
+  layers: import_zod55.z.array(import_zod55.z.string()),
   // Specify layers where the keepout applies
-  description: import_zod54.z.string().optional()
+  description: import_zod55.z.string().optional()
   // Optional description of the keepout
-}).and(
-  import_zod54.z.object({
-    shape: import_zod54.z.literal("rect"),
-    x: distance,
-    y: distance,
-    width: distance,
-    height: distance
-  }).or(
-    import_zod54.z.object({
-      shape: import_zod54.z.literal("circle"),
-      center: point,
-      radius: distance
-    })
-  )
+}).or(
+  import_zod55.z.object({
+    type: import_zod55.z.literal("pcb_keepout"),
+    shape: import_zod55.z.literal("circle"),
+    center: point,
+    radius: distance,
+    pcb_keepout_id: import_zod55.z.string(),
+    layers: import_zod55.z.array(import_zod55.z.string()),
+    // Specify layers where the keepout applies
+    description: import_zod55.z.string().optional()
+    // Optional description of the keepout
+  })
 );
 
 // src/cad/cad_component.ts
-var import_zod55 = require("zod");
-var cad_component = import_zod55.z.object({
-  type: import_zod55.z.literal("cad_component"),
-  cad_component_id: import_zod55.z.string(),
-  pcb_component_id: import_zod55.z.string(),
-  source_component_id: import_zod55.z.string(),
+var import_zod56 = require("zod");
+var cad_component = import_zod56.z.object({
+  type: import_zod56.z.literal("cad_component"),
+  cad_component_id: import_zod56.z.string(),
+  pcb_component_id: import_zod56.z.string(),
+  source_component_id: import_zod56.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_zod55.z.string().optional(),
-  model_obj_url: import_zod55.z.string().optional(),
-  model_stl_url: import_zod55.z.string().optional(),
-  model_3mf_url: import_zod55.z.string().optional(),
-  model_jscad: import_zod55.z.any().optional()
+  footprinter_string: import_zod56.z.string().optional(),
+  model_obj_url: import_zod56.z.string().optional(),
+  model_stl_url: import_zod56.z.string().optional(),
+  model_3mf_url: import_zod56.z.string().optional(),
+  model_jscad: import_zod56.z.any().optional()
 }).describe("Defines a component on the PCB");
 
-// src/any_soup_element.ts
-var import_zod56 = require("zod");
-var any_soup_element = import_zod56.z.union([
+// src/any_circuit_element.ts
+var import_zod57 = require("zod");
+var any_circuit_element = import_zod57.z.union([
   source_trace,
   source_port,
   any_source_component,
@@ -927,6 +1039,7 @@ var any_soup_element = import_zod56.z.union([
   pcb_component,
   pcb_hole,
   pcb_plated_hole,
+  pcb_keepout,
   pcb_port,
   pcb_text,
   pcb_trace,
@@ -956,15 +1069,18 @@ var any_soup_element = import_zod56.z.union([
   schematic_net_label,
   cad_component
 ]);
+var any_soup_element = any_circuit_element;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   all_layers,
+  any_circuit_element,
   any_soup_element,
   any_source_component,
   cad_component,
   capacitance,
   current,
   distance,
+  getZodPrefixedIdWithDefault,
   inductance,
   layer_ref,
   layer_string,
@@ -974,6 +1090,8 @@ var any_soup_element = import_zod56.z.union([
   pcb_fabrication_note_path,
   pcb_fabrication_note_text,
   pcb_hole,
+  pcb_hole_circle_or_square_shape,
+  pcb_hole_oval_shape,
   pcb_keepout,
   pcb_placement_error,
   pcb_plated_hole,
@@ -992,6 +1110,9 @@ var any_soup_element = import_zod56.z.union([
   pcb_trace,
   pcb_trace_error,
   pcb_trace_hint,
+  pcb_trace_route_point,
+  pcb_trace_route_point_via,
+  pcb_trace_route_point_wire,
   pcb_via,
   point,
   point3,
@@ -1006,6 +1127,7 @@ var any_soup_element = import_zod56.z.union([
   schematic_line,
   schematic_net_label,
   schematic_path,
+  schematic_pin_styles,
   schematic_port,
   schematic_text,
   schematic_trace,